@testim/testim-cli 3.231.0 → 3.234.0

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/featureFlags.js

@@ -53,10 +53,10 @@ class FeatureFlagsService {
             useSameBrowserForMultiTests: new LabFeatureFlag('labs'),
             highSpeedMode: new LabFeatureFlag(),
             usePortedHtml5DragDrop: new Rox.Flag(),
-            applitoolsNewIntegration: new Rox.Flag(),
             testNamesToBeforeSuiteHook: new Rox.Flag(),
             addCustomCapabilities: new Rox.Variant('{}'),
             enableWorkerThreadsCliCodeExecution: new Rox.Flag(true),
+            LTNetworkCapabilities: new Rox.Flag(),
         };
         Rox.register('default', this.flags);
     }

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,
 };