@testim/testim-cli 3.232.0 → 3.235.0

package/agent/routers/cliJsCode/service.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const path = require('path');
-const findRoot = require('find-root');
+const os = require('os');
 const dataUriToBuffer = require('data-uri-to-buffer');
 const { spawn: threadSpawn, config } = require('threads');
 const Promise = require('bluebird');
@@ -20,8 +20,6 @@ config.set({
     },
 });
 
-const transactions = {};
-
 function convertWindowsBackslash(input) {
     const isExtendedLengthPath = /^\\\\\?\\/.test(input);
     const hasNonAscii = /[^\u0000-\u0080]+/.test(input); // eslint-disable-line no-control-regex
@@ -549,35 +547,13 @@ function removeFolder(installFolder) {
         }));
 }
 
-function cleanPackages(transactionId) {
-    function cleanInstallFolder() {
-        const { installFolder } = transactions[transactionId];
-        if (!installFolder) {
-            return Promise.resolve();
-        }
-        return removeFolder(installFolder);
-    }
-
-    if (!transactions[transactionId]) {
-        return Promise.resolve();
-    }
-
-    return cleanInstallFolder()
-        .finally(() => delete transactions[transactionId]);
-}
-
 function getTransactionId(stepResultId, testResultId, stepId, retryIndex) {
     return `${testResultId}_${stepId}_${stepResultId}_${retryIndex}`;
 }
 
 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 data;
-        });
+    return runNpmInstall(transactionId, packageData, timeout).then(({ data }) => data);
 }
 
 function runCodeWithPackages(code, stepId, incomingParams, context, testResultId, retryIndex, stepResultId, timeout, fileDataUrl, s3filepath) {
@@ -608,8 +584,7 @@ function runCodeWithPackages(code, stepId, incomingParams, context, testResultId
             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));
+    }).then(res => Object.assign({}, res, { nodeVersion: process.version }));
 }
 
 function runNpmInstall(transactionId, packageData, timeout) {
@@ -653,16 +628,7 @@ function runNpmInstall(transactionId, packageData, timeout) {
 }
 
 function getLocalPackageInstallFolder() {
-    function getRoot() {
-        try {
-            return findRoot(process.cwd());
-        } catch (err) {
-            return process.cwd();
-        }
-    }
-
-    const root = getRoot();
-    return path.join(root, '/testim_local_packages');
+    return path.join(os.tmpdir(), '/testim_local_packages');
 }
 
 function cleanLocalPackageInstallFolder() {

package/cli.js

@@ -94,6 +94,12 @@ function main() {
                 return undefined;
             }
 
+            if (options.tunnelOnlyMode) {
+                await testRunner.init(options);
+                await require('./commons/testimTunnel').serveTunneling(options);
+                return undefined;
+            }
+
             if (agentMode.shouldStartAgentMode(options)) {
                 return agentMode.runAgentMode(options);
             }

package/commons/httpRequest.js

@@ -37,8 +37,8 @@ const logErrorAndRethrow = (logMsg, data) => err => {
     throw err;
 };
 
-function deleteMethod(url, headers, timeout) {
-    return deleteFullRes(url, headers, timeout)
+function deleteMethod(url, body, headers, timeout) {
+    return deleteFullRes(url, body, headers, timeout)
         .then(res => {
             if (res.type === 'text/plain') {
                 return res.text;
@@ -48,9 +48,10 @@ function deleteMethod(url, headers, timeout) {
         .catch(logErrorAndRethrow('failed to delete request', { url }));
 }
 
-function deleteFullRes(url, headers = {}, timeout = DEFAULT_REQUEST_TIMEOUT) {
+function deleteFullRes(url, body = {}, headers = {}, timeout = DEFAULT_REQUEST_TIMEOUT) {
     const request = superagent
         .delete(url)
+        .send(body)
         .timeout(timeout)
         .set(headers);
 

package/commons/testimCloudflare.js

@@ -0,0 +1,76 @@
+'use strict';
+
+const os = require('os');
+const path = require('path');
+const { spawn } = require('child_process');
+const fse = require('fs-extra');
+const { downloadAndSave, unzipFile } = require('../utils');
+const servicesApi = require('./testimServicesApi.js');
+
+const TUNNEL_BINARY_ORIGIN = 'https://github.com/cloudflare/cloudflared/releases/download/2022.4.1/';
+const TUNNEL_BINARY_PATHNAME = {
+    win32ia32: { path: 'cloudflared-windows-386.exe' },
+    win32x64: { path: 'cloudflared-windows-amd64.exe' },
+    darwinx64: { path: 'cloudflared-darwin-amd64.tgz', extract: true },
+    linuxia32: { path: 'cloudflared-linux-386' },
+    linuxx64: { path: 'cloudflared-linux-amd64' },
+};
+const TUNNEL_BINARY_DIRECTORY = os.tmpdir();
+const TUNNEL_BINARY_LOCATION = `${TUNNEL_BINARY_DIRECTORY}/cloudflared`;
+
+
+let tunnelId = null;
+let tunnelProcess = null;
+
+async function prepareTunnel() {
+    const isBinaryExist = await fse.pathExists(TUNNEL_BINARY_LOCATION);
+    if (isBinaryExist) {
+        return;
+    }
+
+    const downloadUrl = TUNNEL_BINARY_PATHNAME[os.platform() + os.arch()];
+    if (!downloadUrl) {
+        throw new Error(`tunnel on ${os.platform() + os.arch()} platform is not supported.`);
+    }
+    const destination = downloadUrl.extract ? TUNNEL_BINARY_DIRECTORY + downloadUrl.path : TUNNEL_BINARY_LOCATION;
+    await downloadAndSave(`${TUNNEL_BINARY_ORIGIN}/${downloadUrl.path}`, destination);
+    if (downloadUrl.extract) {
+        await unzipFile(destination, TUNNEL_BINARY_DIRECTORY);
+    }
+    await fse.chmodSync(TUNNEL_BINARY_LOCATION, '755');
+}
+
+const connectTunnel = async (options) => {
+    const [result] = await Promise.all([
+        servicesApi.getCloudflareTunnel(options.company.companyId, options.tunnelRoutes),
+        prepareTunnel(),
+    ]);
+    tunnelId = result._id;
+    tunnelProcess = spawn(TUNNEL_BINARY_LOCATION, ['tunnel', '--no-autoupdate', 'run', '--force', '--token', result.token], { stdio: 'inherit' });
+    await servicesApi.forceUpdateCloudflareTunnelRoutes(options.company.companyId, tunnelId);
+    await fse.writeFileSync(options.tunnelRoutesOutput, JSON.stringify(result.routesMapping, null, 2));
+};
+
+const disconnectTunnel = async (options) => {
+    const promises = [];
+    if (tunnelId) {
+        promises.push(servicesApi.deleteCloudflareTunnel(options.company.companyId, tunnelId));
+    }
+    if (tunnelProcess) {
+        promises.push(new Promise((resolve, reject) => {
+            tunnelProcess.on('close', (code) => {
+                if (code) {
+                    reject();
+                }
+                resolve();
+            });
+            tunnelProcess.kill();
+        }));
+    }
+    return await Promise.all(promises);
+};
+
+module.exports = {
+    connectTunnel,
+    disconnectTunnel,
+};

package/commons/testimServicesApi.js

@@ -55,6 +55,11 @@ function putAuth(url, body) {
         .then(headers => httpRequest.put(`${config.SERVICES_HOST}${url || ''}`, body, headers));
 }
 
+function deleteAuth(url, body) {
+    return getTokenHeader()
+        .then(headers => httpRequest.delete(`${config.SERVICES_HOST}${url || ''}`, body, headers));
+}
+
 function getWithAuth(url, query, options, timeout) {
     return getTokenHeader()
         .then(headers => httpRequest.get(`${config.SERVICES_HOST}${url || ''}`, query, headers, timeout, options));
@@ -444,6 +449,32 @@ function getApplitoolsIntegrationData(projectId) {
     }
 }
 
+
+function getCloudflareTunnel(companyId, routes) {
+    try {
+        return putAuth('/tunnel', { companyId, routes });
+    } catch (err) {
+        logger.warn('could\'nt get tunnel.', { err });
+        return {};
+    }
+}
+function forceUpdateCloudflareTunnelRoutes(companyId, tunnelId) {
+    try {
+        return postAuth({ url: `/tunnel/${tunnelId}`, body: { companyId } });
+    } catch (err) {
+        logger.warn('could\'nt get tunnel.', { err });
+        return {};
+    }
+}
+function deleteCloudflareTunnel(companyId, tunnelId) {
+    try {
+        return deleteAuth(`/tunnel/${tunnelId}`, { companyId });
+    } catch (err) {
+        logger.warn('could\'nt get tunnel.', { err });
+        return {};
+    }
+}
+
 module.exports = {
     getS3Artifact,
     getTestPlan,
@@ -476,4 +507,7 @@ module.exports = {
     loadTest,
     isTestResultCompleted,
     getApplitoolsIntegrationData,
+    getCloudflareTunnel,
+    forceUpdateCloudflareTunnelRoutes,
+    deleteCloudflareTunnel,
 };

package/commons/testimTunnel.js

@@ -3,22 +3,29 @@
 const ora = require('ora');
 
 const LambdatestService = require('../services/lambdatestService');
+const { registerExitHook } = require('../processHandler');
+const testimCustomToken = require('./testimCustomToken');
 const { gridTypes } = require('./constants');
 const testimNgrok = require('./testimNgrok');
+const testimCloudflare = require('./testimCloudflare');
 const logger = require('./logger').getLogger('tunnel');
 
-const shouldUseLambdatestTunnel = options => [gridTypes.LAMBDATEST, gridTypes.HYBRID].includes(options.gridData.type) && options.gridData.tunnel !== 'ngrok';
+const shouldUseLambdatestTunnel = options => [gridTypes.LAMBDATEST, gridTypes.HYBRID].includes(options.gridData && options.gridData.type) && options.gridData.tunnel !== 'ngrok';
 
-const connect = async (options, authData) => {
+const connect = async (options) => {
     if (!options.tunnel) {
         return;
     }
 
+    const authData = testimCustomToken.getTokenV3UserData();
     let spinner;
     try {
         if (shouldUseLambdatestTunnel(options)) {
             spinner = ora('Starting testim lambdatest tunnel...').start();
             await LambdatestService.connectTunnel(options);
+        } else if (options.tunnelRoutes) {
+            spinner = ora('Starting testim cloudflare tunnel...').start();
+            await testimCloudflare.connectTunnel(options);
         } else {
             spinner = ora('Starting testim ngrok tunnel...').start();
             await testimNgrok.connectTunnel(options, authData);
@@ -40,6 +47,8 @@ const disconnect = async (options) => {
     try {
         if (shouldUseLambdatestTunnel(options)) {
             await LambdatestService.disconnectTunnel(options);
+        } else if (options.tunnelRoutes) {
+            await testimCloudflare.disconnectTunnel(options);
         } else {
             await testimNgrok.disconnectTunnel(options);
         }
@@ -50,7 +59,14 @@ const disconnect = async (options) => {
     }
 };
 
+const serveTunneling = async (options) => {
+    await connect(options);
+    registerExitHook(() => disconnect(options));
+    return await new Promise(() => { /* avoid exiting process */ });
+};
+
 module.exports = {
     connect,
     disconnect,
+    serveTunneling,
 };