@testim/testim-cli 3.228.0 → 3.231.0

package/agent/routers/cliJsCode/service.js

@@ -1,4 +1,4 @@
-"use strict";
+'use strict';
 
 const path = require('path');
 const findRoot = require('find-root');
@@ -7,16 +7,17 @@ const { spawn: threadSpawn, config } = require('threads');
 const Promise = require('bluebird');
 const fs = require('fs-extra');
 const utils = require('../../../utils');
-const logger = require('../../../commons/logger').getLogger("cli-service");
+const logger = require('../../../commons/logger').getLogger('cli-service');
 const { getS3Artifact } = require('../../../commons/testimServicesApi');
 const npmWrapper = require('../../../commons/npmWrapper');
 const featureFlags = require('../../../commons/featureFlags');
-const { NpmPackageError } = require('../../../errors');
+
+let workerThreads;
 
 config.set({
     basepath: {
-        node: __dirname
-    }
+        node: __dirname,
+    },
 });
 
 const transactions = {};
@@ -32,19 +33,19 @@ function convertWindowsBackslash(input) {
     return input.replace(/\\/g, '/');
 }
 
-function runCode(transactionId, incomingParams, context, code, packageLocalLocations = {}, timeout, fileDataUrl) {
+function runCode(transactionId, incomingParams, context, code, packageLocalLocations = {}, timeout = undefined, fileDataUrl = undefined) {
     const requireCode = Object.keys(packageLocalLocations).reduce((all, pMember) => {
         all += `
         var ${pMember} = require('${convertWindowsBackslash(packageLocalLocations[pMember])}');
         `;
         return all;
-    }, "");
+    }, '');
 
     if (fileDataUrl === 'data:') { // fix chrome/safari bug that creates malformed datauri for empty files
         fileDataUrl = 'data:,';
     }
 
-    const fileDataUrlToFileBuffer = !fileDataUrl ? `var fileBuffer = null;` :
+    const fileDataUrlToFileBuffer = !fileDataUrl ? 'var fileBuffer = null;' :
         `
             ${dataUriToBuffer.toString()}
             var fileBuffer = dataUriToBuffer('${fileDataUrl}');
@@ -212,7 +213,7 @@ function runCode(transactionId, incomingParams, context, code, packageLocalLocat
         thread
             .send({ incomingParams, context, code })
             .on('message', message => {
-                const messageWithLogs = Object.assign({}, message, { tstConsoleLogs: testimConsoleLogDataAggregates })
+                const messageWithLogs = Object.assign({}, message, { tstConsoleLogs: testimConsoleLogDataAggregates });
                 logger.debug('Run code worker response', { messageWithLogs, transactionId });
                 resolve(messageWithLogs);
             })
@@ -220,7 +221,7 @@ function runCode(transactionId, incomingParams, context, code, packageLocalLocat
                 testimConsoleLogDataAggregates.push(logMessage);
             })
             .on('error', (err) => {
-                if (err.message === "malformed data: URI") {
+                if (err.message === 'malformed data: URI') {
                     logger.error('Run code worker error', { err, transactionId, fileDataUrl });
                 } else {
                     logger.error('Run code worker error', { err, transactionId });
@@ -233,9 +234,9 @@ function runCode(transactionId, incomingParams, context, code, packageLocalLocat
                         resultValue: err && err.toString(),
                         exports: {},
                         exportsTest: {},
-                        exportsGlobal: {}
+                        exportsGlobal: {},
                     },
-                    success: false
+                    success: false,
                 });
             })
             .on('exit', () => {
@@ -243,7 +244,7 @@ function runCode(transactionId, incomingParams, context, code, packageLocalLocat
             });
     }).timeout(timeout)
         .catch(Promise.TimeoutError, err => {
-            logger.warn("timeout to run code", { transactionId, err });
+            logger.warn('timeout to run code', { transactionId, err });
             return Promise.resolve({
                 tstConsoleLogs: testimConsoleLogDataAggregates,
                 status: 'failed',
@@ -251,23 +252,301 @@ function runCode(transactionId, incomingParams, context, code, packageLocalLocat
                     resultValue: err && err.toString(),
                     exports: {},
                     exportsTest: {},
-                    exportsGlobal: {}
+                    exportsGlobal: {},
                 },
-                success: false
+                success: false,
             });
         })
         .finally(() => thread && thread.kill());
 }
 
-function removeFolder(installFolder) {
-    return new Promise(resolve => {
-        return fs.remove(installFolder)
-            .then(resolve)
-            .catch(err => {
-                logger.warn(`failed to remove install npm packages folder`, { err });
-                return resolve();
+function requireOrImportMethod(path) {
+    try {
+        return { sync: true, lib: require(path) };
+    } catch (err) {
+        if (err.code === 'ERR_REQUIRE_ESM') {
+            const fs = require('fs');
+            const pathModule = require('path');
+
+            const lib = fs.promises.readFile(`${path}${pathModule.sep}package.json`).then(file => {
+                const packageJson = JSON.parse(file);
+                const fullPath = pathModule.join(path, packageJson.main || `${pathModule.sep}index.js`);
+                return import(fullPath);
+            });
+
+            return { sync: false, lib };
+        }
+        throw err;
+    }
+}
+
+function runCodeWithWorkerThread(transactionId, incomingParams, context, code, packageLocalLocations = {}, timeout = undefined, fileDataUrl = undefined) {
+    // technically shouldn't happen, but better safe than sorry.
+    if (!workerThreads) {
+        workerThreads = require('worker_threads');
+    }
+    const { Worker } = workerThreads;
+    const requireCode = Object.keys(packageLocalLocations).reduce((all, pMember) => {
+        all += `
+        var res = requireOrImportMethod('${convertWindowsBackslash(packageLocalLocations[pMember])}');
+        if (res.sync) {
+            var ${pMember} = res.lib;
+        } else {
+            var ${pMember} = await res.lib;
+        }
+        `;
+        return all;
+    }, '');
+
+    if (fileDataUrl === 'data:') { // fix chrome/safari bug that creates malformed datauri for empty files
+        fileDataUrl = 'data:,';
+    }
+
+    const fileDataUrlToFileBuffer = !fileDataUrl ? 'var fileBuffer = null;' :
+        `
+            ${dataUriToBuffer.toString()}
+            var fileBuffer = dataUriToBuffer('${fileDataUrl}');
+        `;
+
+    function constructWithArguments(constructor, args) {
+        function F() {
+            return constructor.apply(this, args);
+        }
+
+        F.prototype = constructor.prototype;
+        return new F();
+    }
+
+    //https://github.com/anseki/console-substitute
+    // note that this method is a bit different than the one in the non-worker one.
+    const consoleOverride = `
+        const getMessage = arguments => {
+            const args = Array.prototype.slice.call(arguments);
+            let message = args.shift() + '';
+            if (!args.length) {
+                return message;
+            }
+            message = message.replace(/%([odifs])/g, function (s, param) {
+                // Formatting is not yet supported.
+                var arg;
+                if (!args.length) {
+                    return '';
+                }
+                arg = args.shift();
+                if (param === 'o') {
+                    return arg + '';
+                } else if (param === 'd' || param === 'i') {
+                    arg = typeof arg === 'boolean' ? (arg ? 1 : 0) : parseInt(arg, 10);
+                    return isNaN(arg) ? '0' : arg + '';
+                } else if (param === 'f') {
+                    arg = typeof arg === 'boolean' ? (arg ? 1 : 0) : parseFloat(arg);
+                    return isNaN(arg) ? '0.000000' : arg.toFixed(6) + '';
+                } else if (param === 's') {
+                    return arg + '';
+                }
+            });
+            if (message) {
+                args.unshift(message);
+            }
+            return args.join(' ').replace(/\\s*$/, ' ');
+        };
+
+        const pushNewMessage = (method, consoleArgs) => {
+            const message = getMessage(consoleArgs);
+            parentPort.postMessage({
+                action: 'progress',
+                data: {
+                    method,
+                    msg: message,
+                    timestamp: Date.now(),
+                }
+            });
+        };
+
+        ["log", "info", "warn", "error", "debug"].forEach(function (method) {
+            const nativeMethod = console[method];
+            const oldMethod = nativeMethod && nativeMethod.bind(console);
+            console[method] = function () {
+                pushNewMessage(method, arguments);
+                oldMethod && oldMethod.apply(console, arguments);
+            };
+        });
+    `;
+
+    const injectCode = `
+        function injectCode(params, args, incomingParams, context, code) {
+            ${constructWithArguments.toString()}
+
+            var resolve = function (result) {
+                parentPort.postMessage({
+                    action: 'finish',
+                    data: {
+                        status: 'done',
+                        result: result,
+                        success: true,
+                    }
+                });
+            };
+            var reject = function (result) {
+                parentPort.postMessage({
+                    action: 'finish',
+                    data: {
+                        status: 'failed',
+                        result: result,
+                        success: false,
+                    }
+                });
+            };
+
+            try {
+                params.push(code);
+                const AsyncFunction = Object.getPrototypeOf(async function(){}).constructor;
+                var functionToRun = constructWithArguments(AsyncFunction, params);
+
+                var result = functionToRun.apply(null, args);
+                if (isPromise(result)) {
+                    result.then(function (res) {
+                        resolve({
+                            resultValue: res,
+                            exports: exportedData,
+                            exportsTest: exportedTestData,
+                            exportsGlobal: exportedGlobalData
+                        });
+                    }).catch(function (err) {
+                        reject({
+                            resultValue: err && err.toString(),
+                            exports: exportedData,
+                            exportsTest: exportedTestData,
+                            exportsGlobal: exportedGlobalData
+                        });
+                    });
+                } else {
+                    resolve({
+                        resultValue: result,
+                        exports: exportedData,
+                        exportsTest: exportedTestData,
+                        exportsGlobal: exportedGlobalData
+                    });
+                }
+            } catch (e) {
+                reject({
+                    resultValue: e && e.toString(),
+                    exports: exportedData,
+                    exportsTest: exportedTestData,
+                    exportsGlobal: exportedGlobalData
+                });
+            }
+        }
+    `;
+
+    const runFn = `
+        (async function() {
+            const { parentPort } = require('worker_threads');
+            ${requireOrImportMethod}
+
+            // requireCode will set async to be true if needed.
+            ${requireCode}
+
+            ${fileDataUrlToFileBuffer}
+
+            ${consoleOverride}
+
+            ${utils.isPromise.toString()}
+
+            parentPort.once('message', input => {
+                const {incomingParams, context, code} = input;
+
+                var exportedData = {};
+                var exportedTestData = {};
+                var exportedGlobalData = {};
+
+                var params = ["context"]
+                    .concat(incomingParams.as.functionParameters)
+                    .concat(${JSON.stringify(Object.keys(packageLocalLocations))})
+                    .concat(['exports', 'exportsTest', 'exportsGlobal']);
+
+                var args = [context]
+                    .concat(incomingParams.as.functionArguments)
+                    .concat([${Object.keys(packageLocalLocations).join(',')}])
+                    .concat([exportedData, exportedTestData, exportedGlobalData]);
+
+                if(fileBuffer) {
+                    params = params.concat(['fileBuffer']);
+                    args = args.concat([fileBuffer]);
+                }
+
+                ${injectCode}
+
+                injectCode(params, args, incomingParams, context, code);
             });
+        })();
+    `;
+
+    const testimConsoleLogDataAggregates = [];
+    const thread = new Worker(runFn, {
+        eval: true,
     });
+    return new Promise((resolve) => {
+        thread
+            .on('message', message => {
+                if (message.action === 'finish') {
+                    const { data } = message;
+                    const messageWithLogs = Object.assign({}, data, { tstConsoleLogs: testimConsoleLogDataAggregates });
+                    logger.debug('Run code worker response', { messageWithLogs, transactionId });
+                    resolve(messageWithLogs);
+                } else if (message.action === 'progress') {
+                    testimConsoleLogDataAggregates.push(message.data);
+                }
+            })
+            .on('error', (err) => {
+                if (err.message === 'malformed data: URI') {
+                    logger.error('Run code worker error', { err, transactionId, fileDataUrl });
+                } else {
+                    logger.error('Run code worker error', { err, transactionId });
+                }
+
+                resolve({
+                    tstConsoleLogs: testimConsoleLogDataAggregates,
+                    status: 'failed',
+                    result: {
+                        resultValue: err && err.toString(),
+                        exports: {},
+                        exportsTest: {},
+                        exportsGlobal: {},
+                    },
+                    success: false,
+                });
+            })
+            .on('exit', () => {
+                logger.debug('Run code worker has been terminated', { transactionId });
+            });
+        // context can contain methods and proxies which cannot pass.
+        thread.postMessage({ incomingParams, context: JSON.parse(JSON.stringify(context)), code });
+    }).timeout(timeout)
+        .catch(Promise.TimeoutError, err => {
+            logger.warn('timeout to run code', { transactionId, err });
+            return Promise.resolve({
+                tstConsoleLogs: testimConsoleLogDataAggregates,
+                status: 'failed',
+                result: {
+                    resultValue: err && err.toString(),
+                    exports: {},
+                    exportsTest: {},
+                    exportsGlobal: {},
+                },
+                success: false,
+            });
+        })
+        .finally(() => thread && thread.terminate());
+}
+
+function removeFolder(installFolder) {
+    return new Promise(resolve => fs.remove(installFolder)
+        .then(resolve)
+        .catch(err => {
+            logger.warn('failed to remove install npm packages folder', { err });
+            return resolve();
+        }));
 }
 
 function cleanPackages(transactionId) {
@@ -291,31 +570,14 @@ function getTransactionId(stepResultId, testResultId, stepId, retryIndex) {
     return `${testResultId}_${stepId}_${stepResultId}_${retryIndex}`;
 }
 
-function mapNpmInstallDataToInstallData(npmInstallData, packageData) {
-    const npmInstallDataObject = npmInstallData.reduce((obj, [packageFullName, packageLocalLocation]) => {
-        const strudelIndex = packageFullName.lastIndexOf('@');
-        const npmInstalledPackageName = packageFullName.substr(0, strudelIndex);
-        obj[npmInstalledPackageName] = {
-            packageFullName,
-            packageLocalLocation
-        };
-        return obj;
-    }, {});
-    return packageData.map(data => {
-        const npmPackageName = data.packageName;
-        return Object.assign({}, npmInstallDataObject[npmPackageName], data);
-    });
-}
-
 function installPackage(stepId, testResultId, retryIndex, packageData, stepResultId, timeout) {
     const transactionId = getTransactionId(stepResultId, testResultId, stepId, retryIndex);
     return runNpmInstall(transactionId, packageData, timeout)
         .then(({ data, installFolder }) => {
             transactions[transactionId] = transactions[transactionId] || {};
             transactions[transactionId].installFolder = installFolder;
-            return Promise.resolve(data);
+            return data;
         });
-
 }
 
 function runCodeWithPackages(code, stepId, incomingParams, context, testResultId, retryIndex, stepResultId, timeout, fileDataUrl, s3filepath) {
@@ -333,8 +595,20 @@ function runCodeWithPackages(code, stepId, incomingParams, context, testResultId
         if (s3fileDataUrl) {
             fileDataUrl = s3fileDataUrl;
         }
-    }).then(() => runCode(transactionId, incomingParams, context, code, packageLocalLocations, timeout, fileDataUrl))
-        .then(res => Object.assign({}, res, { nodeVersion: process.version }))
+    }).then(() => {
+        if (typeof workerThreads === 'undefined') {
+            try {
+                workerThreads = require('worker_threads');
+            } catch (err) {
+                workerThreads = false;
+            }
+        }
+
+        if (workerThreads && featureFlags.flags.enableWorkerThreadsCliCodeExecution.isEnabled()) {
+            return runCodeWithWorkerThread(transactionId, incomingParams, context, code, packageLocalLocations, timeout, fileDataUrl);
+        }
+        return runCode(transactionId, incomingParams, context, code, packageLocalLocations, timeout, fileDataUrl);
+    }).then(res => Object.assign({}, res, { nodeVersion: process.version }))
         .finally(() => cleanPackages(transactionId));
 }
 
@@ -343,6 +617,9 @@ function runNpmInstall(transactionId, packageData, timeout) {
     const localPackageInstallFolder = getLocalPackageInstallFolder();
     const installFolder = path.join(localPackageInstallFolder, `/${transactionId}`);
     const proxyUri = global.proxyUri;
+
+    // while correct, everything is in a try/catch so it should be fine.
+    // eslint-disable-next-line no-async-promise-executor
     return new Promise(async (resolve, reject) => {
         let output = '';
         try {
@@ -358,8 +635,8 @@ function runNpmInstall(transactionId, packageData, timeout) {
                 const packageLocalLocation = path.resolve(installFolder, 'node_modules', pData.packageName);
                 return Object.assign({}, pData, {
                     packageFullName,
-                    packageLocalLocation
-                })
+                    packageLocalLocation,
+                });
             });
 
             resolve({ data: packageDataWithVersions, installFolder });
@@ -367,11 +644,10 @@ function runNpmInstall(transactionId, packageData, timeout) {
             logger.warn('npm package install failed', { transactionId, err });
             reject(err);
         }
-
     })
         .timeout(timeout)
         .catch(Promise.TimeoutError, err => {
-            logger.warn("timeout to install package", { packages, transactionId, err, timeout });
+            logger.warn('timeout to install package', { packages, transactionId, err, timeout });
             throw err;
         });
 }
@@ -397,5 +673,5 @@ function cleanLocalPackageInstallFolder() {
 module.exports = {
     runCodeWithPackages,
     installPackage,
-    cleanLocalPackageInstallFolder
+    cleanLocalPackageInstallFolder,
 };

package/commons/featureFlags.js

@@ -56,6 +56,7 @@ class FeatureFlagsService {
             applitoolsNewIntegration: new Rox.Flag(),
             testNamesToBeforeSuiteHook: new Rox.Flag(),
             addCustomCapabilities: new Rox.Variant('{}'),
+            enableWorkerThreadsCliCodeExecution: new Rox.Flag(true),
         };
         Rox.register('default', this.flags);
     }