@testim/testim-cli 3.267.0 → 3.269.0

package/agent/routers/cliJsCode/service.js

@@ -1,3 +1,5 @@
+// @ts-check
+
 'use strict';
 
 const path = require('path');
@@ -5,7 +7,8 @@ const os = require('os');
 const dataUriToBuffer = require('data-uri-to-buffer');
 const { spawn: threadSpawn, config } = require('threads');
 const Promise = require('bluebird');
-const fs = require('fs-extra');
+const fse = require('fs-extra');
+const fs = require('fs');
 const utils = require('../../../utils');
 const logger = require('../../../commons/logger').getLogger('cli-service');
 const { getS3Artifact } = require('../../../commons/testimServicesApi');
@@ -13,6 +16,7 @@ const npmWrapper = require('../../../commons/npmWrapper');
 const featureFlags = require('../../../commons/featureFlags');
 const { TimeoutError } = require('../../../errors');
 
+/** @type {import('worker_threads') | false} */
 let workerThreads;
 
 config.set({
@@ -32,6 +36,15 @@ function convertWindowsBackslash(input) {
     return input.replace(/\\/g, '/');
 }
 
+/**
+ * @param {string} transactionId
+ * @param {any} incomingParams
+ * @param {any} context
+ * @param {any} code
+ * @param {Record<string, any>} packageLocalLocations
+ * @param {number=} timeout
+ * @param {string=} fileDataUrl
+ */
 function runCode(transactionId, incomingParams, context, code, packageLocalLocations = {}, timeout = undefined, fileDataUrl = undefined) {
     const requireCode = Object.keys(packageLocalLocations).reduce((all, pMember) => {
         all += `
@@ -204,7 +217,7 @@ function runCode(transactionId, incomingParams, context, code, packageLocalLocat
 
     const testimConsoleLogDataAggregates = [];
     const thread = threadSpawn(constructWithArguments(Function, ['input', 'done', 'progress', runFn]));
-    return new Promise((resolve) => {
+    return utils.promiseTimeout(new Promise((resolve) => {
         thread
             .send({ incomingParams, context, code })
             .on('message', message => {
@@ -226,7 +239,7 @@ function runCode(transactionId, incomingParams, context, code, packageLocalLocat
                     tstConsoleLogs: testimConsoleLogDataAggregates,
                     status: 'failed',
                     result: {
-                        resultValue: err && err.toString(),
+                        resultValue: err?.toString(),
                         exports: {},
                         exportsTest: {},
                         exportsGlobal: {},
@@ -237,22 +250,25 @@ function runCode(transactionId, incomingParams, context, code, packageLocalLocat
             .on('exit', () => {
                 logger.debug('Run code worker has been terminated', { transactionId });
             });
-    }).timeout(timeout)
-        .catch(Promise.TimeoutError, err => {
+    }), timeout)
+        .catch(err => {
+            if (!(err instanceof utils.TimeoutError)) {
+                throw err;
+            }
             logger.warn('timeout to run code', { transactionId, err });
-            return Promise.resolve({
+            return {
                 tstConsoleLogs: testimConsoleLogDataAggregates,
                 status: 'failed',
                 result: {
-                    resultValue: err && err.toString(),
+                    resultValue: err?.toString(),
                     exports: {},
                     exportsTest: {},
                     exportsGlobal: {},
                 },
                 success: false,
-            });
+            };
         })
-        .finally(() => thread && thread.kill());
+        .finally(() => thread?.kill());
 }
 
 function requireOrImportMethod(path) {
@@ -260,7 +276,6 @@ function requireOrImportMethod(path) {
         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 => {
@@ -275,7 +290,22 @@ function requireOrImportMethod(path) {
     }
 }
 
-function runCodeWithWorkerThread(transactionId, incomingParams, context, code, packageLocalLocations = {}, timeout = undefined, fileDataUrl = undefined) {
+/**
+ * @param {string} transactionId
+ * @param {any} incomingParams
+ * @param {any} context
+ * @param {any} code
+ * @param {number=} timeout
+ */
+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');
@@ -477,7 +507,7 @@ function runCodeWithWorkerThread(transactionId, incomingParams, context, code, p
     const thread = new Worker(runFn, {
         eval: true,
     });
-    return new Promise((resolve) => {
+    return utils.promiseTimeout(new Promise((resolve) => {
         thread
             .on('message', message => {
                 if (message.action === 'finish') {
@@ -500,7 +530,7 @@ function runCodeWithWorkerThread(transactionId, incomingParams, context, code, p
                     tstConsoleLogs: testimConsoleLogDataAggregates,
                     status: 'failed',
                     result: {
-                        resultValue: err && err.toString(),
+                        resultValue: err?.toString(),
                         exports: {},
                         exportsTest: {},
                         exportsGlobal: {},
@@ -513,26 +543,29 @@ function runCodeWithWorkerThread(transactionId, incomingParams, context, code, p
             });
         // 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 => {
+    }), timeout)
+        .catch(err => {
+            if (!(err instanceof utils.TimeoutError)) {
+                throw err;
+            }
             logger.warn('timeout to run code', { transactionId, err });
-            return Promise.resolve({
+            return {
                 tstConsoleLogs: testimConsoleLogDataAggregates,
                 status: 'failed',
                 result: {
-                    resultValue: err && err.toString(),
+                    resultValue: err?.toString(),
                     exports: {},
                     exportsTest: {},
                     exportsGlobal: {},
                 },
                 success: false,
-            });
+            };
         })
-        .finally(() => thread && thread.terminate());
+        .finally(() => thread?.terminate());
 }
 
 function removeFolder(installFolder) {
-    return new Promise(resolve => fs.remove(installFolder)
+    return new Promise(resolve => fse.remove(installFolder)
         .then(resolve)
         .catch(err => {
             logger.warn('failed to remove install npm packages folder', { err });

package/bluebirdConfig.js

@@ -1,4 +1,4 @@
-"use strict";
+'use strict';
 
 /**
  * Configure bluebird promises
@@ -6,18 +6,19 @@
 const Promise = require('bluebird');
 const { isDebuggerConnected } = require('./commons/detectDebugger');
 const { OVERRIDE_TIMEOUTS } = require('./commons/config');
+
 Promise.config({
     // Disable warnings.
     warnings: false,
     // Enable long stack traces.
     longStackTraces: Boolean(isDebuggerConnected()),
     // Disable cancellation.
-    cancellation: false
+    cancellation: false,
 });
 
 let warnedAboutDebugger = false;
 if (OVERRIDE_TIMEOUTS) {
-    let old = Promise.prototype.timeout;
+    const old = Promise.prototype.timeout;
     const timeoutOverride = Number(OVERRIDE_TIMEOUTS || 6e5);
     if (!OVERRIDE_TIMEOUTS && !warnedAboutDebugger) {
         warnedAboutDebugger = true;
@@ -31,7 +32,7 @@ if (OVERRIDE_TIMEOUTS) {
 if (process.env.IS_BLUEBIRD_NATIVE_PROMISE_SCHEDULER) {
     // If the debugger is connected we skip the trampoline in order to schedule with native promise scheduling
     // which makes the V8 debugger aware of promise scheduling and makes async stack traces work without a lot of unnecessary bluebird-specific frames.
-    const NativePromise = (async function () {})().constructor;
+    const NativePromise = (async function () {}()).constructor;
     const ResolvedNativePromise = NativePromise.resolve();
     Promise.setScheduler(fn => ResolvedNativePromise.then(fn));
 }

package/commons/httpRequest.js

@@ -2,8 +2,8 @@
 
 const logger = require('./logger').getLogger('http-request');
 const superagent = require('superagent');
-const Promise = require('bluebird');
 const { makeCounters } = require('./httpRequestCounters');
+const { promiseFromCallback } = require('../utils/promiseUtils');
 
 const wrapWithMonitoring = makeCounters();
 
@@ -63,7 +63,7 @@ function deleteFullRes(url, body = {}, headers = {}, timeout = DEFAULT_REQUEST_T
         request.proxy(getProxy());
     }
 
-    return Promise.fromCallback((callback) => request.end(callback));
+    return promiseFromCallback((callback) => request.end(callback));
 }
 
 function post({
@@ -98,7 +98,7 @@ function postFullRes(url, body, headers = {}, timeout = DEFAULT_REQUEST_TIMEOUT,
         request.retry(retry);
     }
 
-    return Promise.fromCallback((callback) => request.end(callback)).catch(e => e, e => {
+    return promiseFromCallback((callback) => request.end(callback)).catch(e => e, e => {
         e.url = url;
         e.originalRequestTimeout = timeout;
         e.additionalSetHeaders = headers;
@@ -127,7 +127,7 @@ function postForm(url, fields, files, headers = {}, timeout = DEFAULT_REQUEST_TI
         request.proxy(getProxy());
     }
 
-    return Promise.fromCallback((callback) => request.end(callback))
+    return promiseFromCallback((callback) => request.end(callback))
         .then((res) => {
             if (res.type === 'text/plain') {
                 return res.text;
@@ -156,7 +156,7 @@ function _get(url, query, headers = {}, timeout = DEFAULT_REQUEST_TIMEOUT, { isB
         request.proxy(getProxy());
     }
 
-    return Promise.fromCallback((callback) => request.end(callback));
+    return promiseFromCallback((callback) => request.end(callback));
 }
 
 function getText(url, query, headers) {
@@ -191,7 +191,7 @@ function head(url) {
         request.proxy(getProxy());
     }
 
-    return Promise.fromCallback((callback) => request.end(callback))
+    return promiseFromCallback((callback) => request.end(callback))
         .catch(logErrorAndRethrow('failed to head request', { url }));
 }
 
@@ -210,7 +210,7 @@ function put(url, body, headers = {}, timeout = DEFAULT_REQUEST_TIMEOUT) {
         request.proxy(getProxy());
     }
 
-    return Promise.fromCallback((callback) => request.end(callback))
+    return promiseFromCallback((callback) => request.end(callback))
         .then((res) => res.body)
         .catch(logErrorAndRethrow('failed to put request', { url }));
 }
@@ -236,7 +236,7 @@ function download(url) {
         request.proxy(getProxy());
     }
 
-    return Promise.fromCallback((callback) => request.end(callback))
+    return promiseFromCallback((callback) => request.end(callback))
         .then(response => {
             logger.info('finished to download', { url });
             return response;

package/commons/runnerFileCache.js

@@ -1,13 +1,16 @@
+// @ts-check
+
 'use strict';
 
 const path = require('path');
 const Promise = require('bluebird');
 const debounce = require('lodash/debounce');
-const fs = Promise.promisifyAll(require('fs'));
+const fs = require('fs');
 const { getCliLocation } = require('../utils');
 
 const logger = require('./logger').getLogger('local cache');
 const crypto = require('crypto');
+const utils = require('../utils');
 
 let cacheLocation = path.resolve(getCliLocation(), 'testim-cache');
 
@@ -25,10 +28,19 @@ const THREE_HOURS = 1000 * 60 * 60 * 3;
 
 const getCacheFileLocation = () => path.resolve(path.resolve(cacheLocation, 'testim.cache'));
 
-const getLocalRunnerCache = () => fs.readFileAsync(getCacheFileLocation()).then(async buffer => {
-    const key = await _encryptKeyPromise;
-    return decrypt(key, buffer);
-}).timeout(30000).catch(() => ({}));
+async function getLocalRunnerCache() {
+    try {
+        return await utils.promiseTimeout(
+            fs.promises.readFile(getCacheFileLocation()).then(async buffer => {
+                const key = await _encryptKeyPromise;
+                return decrypt(key, buffer);
+            }),
+            30_000,
+        );
+    } catch {
+        return {};
+    }
+}
 
 let localRunnerCache = getLocalRunnerCache();
 
@@ -59,7 +71,7 @@ const encryptAndSave = debounce(async (object) => {
         if (!pathExists) {
             await fs.promises.mkdir(cacheLocation, { recursive: true });
         }
-        await fs.writeFileAsync(getCacheFileLocation(), result);
+        await fs.promises.writeFile(getCacheFileLocation(), result);
     } catch (err) {
         logger.error('failed saving cache', { err });
         error = err;
@@ -77,6 +89,7 @@ function decrypt(key, buffer) {
     const keyBuffer = Buffer.from(key);
     const decipher = crypto.createDecipheriv('aes-256-cbc', Buffer.concat([keyBuffer, Buffer.alloc(32)], 32), iv);
     const decrypted = decipher.update(encryptedText);
+    // @ts-ignore
     return JSON.parse(Buffer.concat([decrypted, decipher.final()]));
 }
 /**

package/commons/socket/baseSocketServiceSocketIO.js

@@ -4,6 +4,7 @@ const Promise = require('bluebird');
 const pRetry = require('p-retry');
 const io = require('socket.io-client');
 const config = require('../config');
+const utils = require('../../utils');
 
 const MAX_SOCKET_RECONNECT_ATTEMPT = 50;
 const MAX_RECONNECT_ATTEMPT_BEFORE_SWITCH = 10;
@@ -15,7 +16,9 @@ const logger = require('../logger').getLogger('base socket service');
 class BaseSocketServiceSocketIO {
     constructor() {
         this.attempts = 0;
+        /** @type {{ [testResultId: string]: testId }} */
         this.rooms = {};
+        /** @type {undefined | Promise<void>} */
         this.emitPromiseQueue = undefined;
     }
 
@@ -28,10 +31,18 @@ class BaseSocketServiceSocketIO {
         });
     }
 
+    /**
+     * @param {string} resultId
+     * @param {string} testId
+     */
     joinRoom(resultId, testId) {
         this.rooms[resultId] = testId;
     }
 
+    /**
+     * @param {string} resultId
+     * @param {string} testId
+     */
     leaveRoom(resultId) {
         delete this.rooms[resultId];
     }
@@ -97,6 +108,10 @@ class BaseSocketServiceSocketIO {
         });
     }
 
+    /**
+     * @param {string} projectId
+     * @param {string} ns
+     */
     initNewSocket(projectId, ns) {
         const opts = {
             query: { projectId },
@@ -124,6 +139,10 @@ class BaseSocketServiceSocketIO {
         });
     }
 
+    /**
+     * @param {string} projectId
+     * @param {string} ns
+     */
     init(projectId, ns) {
         const opts = {
             query: { projectId },
@@ -146,6 +165,10 @@ class BaseSocketServiceSocketIO {
         this.addSocketHandlers();
     }
 
+    /**
+     * @param {string} eventName
+     * @param {*} eventData
+     */
     emitPromise(eventName, eventData) {
         const errorneousEvents = {};
 
@@ -158,10 +181,10 @@ class BaseSocketServiceSocketIO {
 
                 return reject(new Error('bad ack'));
             });
-        }).timeout(EMIT_PROMISE_TIMEOUT);
+        });
 
         this.emitPromiseQueue = (this.emitPromiseQueue || Promise.resolve())
-            .then(() => pRetry(emitAndWait, { retries: 200, minTimeout: 3000 }))
+            .then(() => pRetry(() => utils.promiseTimeout(emitAndWait(), EMIT_PROMISE_TIMEOUT), { retries: 200, minTimeout: 3000, factor: 1 }))
             .finally(() => {
                 if (Object.keys(errorneousEvents).length > 0) {
                     logger.error('Bad acknowledge from socket emit', { errorneousEvents });

package/commons/socket/testResultService.js

@@ -5,7 +5,6 @@ const { EventEmitter } = require('events');
 const featureFlags = require('../featureFlags');
 
 const { socketEventTypes } = require('../constants');
-const Promise = require('bluebird');
 
 class TestResultService extends EventEmitter {
     init(projectId) {

package/commons/testimDesiredCapabilitiesBuilder.js

@@ -561,11 +561,11 @@ function buildSeleniumOptions(browserOptions, testName, testRunConfig, gridInfo,
 }
 
 //testRunConfig not in used for now
-function buildAppiumOptions({ projectType, gridInfo, testRunConfig, nativeApp, options }) {
+function buildAppiumOptions({ projectType, gridInfo, testRunConfig, nativeApp, options, appPath, androidActivityWait }) {
     const { deviceModel, osVersion, deviceUdid } = options;
     const headspinSelector = {};
 
-    if (!nativeApp) {
+    if (!nativeApp && !appPath) {
         throw Error('missing mobile app!');
     }
     if (gridInfo.type !== gridTypes.TESTIM_HEADSPIN) {
@@ -576,23 +576,38 @@ function buildAppiumOptions({ projectType, gridInfo, testRunConfig, nativeApp, o
         hostname: gridInfo.host,
         port: gridInfo.port,
         path: `/v0/${gridInfo.accessToken}/wd/hub`,
+        // connectionRetryTimeout: 900000, -- not used for now
+    };
+    //TODO: check if more caps should be defined as default
+    let appCaps = {
+        'headspin:capture': true,
+        'appium:autoAcceptAlerts': true,
     };
-
-    let appCaps = {};
     switch (projectType) {
         case 'ios':
             appCaps = {
-                'appium:bundleId': nativeApp.id,
+                ...appCaps,
                 platformName: 'iOS',
                 'appium:automationName': 'XCUITest',
+                ...(nativeApp && { 'appium:bundleId': nativeApp.id }),
+                ...(appPath && {
+                    'appium:app': appPath,
+                }),
             };
             break;
         case 'android':
             appCaps = {
+                ...appCaps,
                 platformName: 'Android',
                 'appium:automationName': 'UiAutomator2',
-                'appium:appPackage': nativeApp.packageName,
-                'appium:appActivity': nativeApp.activity,
+                'appium:appWaitActivity': androidActivityWait,
+                ...(nativeApp && {
+                    'appium:appPackage': nativeApp.id || nativeApp.packageName,
+                    'appium:appActivity': nativeApp.activity,
+                }),
+                ...(appPath && {
+                    'appium:app': appPath,
+                }),
             };
             break;
         default:
@@ -609,7 +624,6 @@ function buildAppiumOptions({ projectType, gridInfo, testRunConfig, nativeApp, o
         delete headspinSelector.model;
         delete headspinSelector.os_version;
     }
-
     if (!_.isEmpty(headspinSelector)) {
         appCaps['headspin:selector'] = headspinSelector;
     }

package/commons/testimServicesApi.js

@@ -237,6 +237,15 @@ function getSuiteTestList({
     }), { retries: DEFAULT_REQUEST_RETRY });
 }
 
+async function getAppDetails({ appId, projectId }) {
+    try {
+        return await pRetry(() => getWithAuth(`/mobile-app/app/${appId}?projectId=${projectId}`), { retries: DEFAULT_REQUEST_RETRY, factor: 1 });
+    } catch (error) {
+        logger.error('failed getting application details', { appId, error });
+        return undefined;
+    }
+}
+
 function getUsageForCurrentBillingPeriod(projectId) {
     return pRetry(() => getWithAuth(`/plan/project/${projectId}/usage-current-billing-period`), { retries: DEFAULT_REQUEST_RETRY })
         .catch((error) => {
@@ -395,10 +404,16 @@ function saveRemoteStep(projectId, resultId, stepId, remoteStep) {
     }), { retries: DEFAULT_REQUEST_RETRY });
 }
 
+/** @param {string} uri */
 function relativize(uri) {
     return uri.startsWith('/') ? uri : `/${uri}`;
 }
 
+/**
+ * @param {string} filePath
+ * @param {string} bucket
+ * @param {string} projectId
+ */
 function getStorageRelativePath(filePath, bucket, projectId) {
     let fullPath = relativize(filePath);
     if (projectId) {
@@ -411,7 +426,15 @@ function getStorageRelativePath(filePath, bucket, projectId) {
     return fullPath;
 }
 
-function uploadArtifact(projectId, testId, testResultId, content, subType, mimeType = 'application/octet-stream') {
+/**
+ * @param {string} projectId
+ * @param {string} testId
+ * @param {string} testResultId
+ * @param {*} content
+ * @param {string} subType
+ * @param {string} mimeType
+ */
+async function uploadArtifact(projectId, testId, testResultId, content, subType, mimeType = 'application/octet-stream') {
     let fileSuffix = null;
     if (mimeType === 'application/json') {
         fileSuffix = '.json';
@@ -431,9 +454,11 @@ function uploadArtifact(projectId, testId, testResultId, content, subType, mimeT
         },
     };
 
-    return pRetry(() => postAuthFormData(`/storage${storagePath}`, {}, files, {
-        'X-Asset-Encoding': 'gzip',
-    }), { retries: DEFAULT_REQUEST_RETRY }).then(() => storagePath);
+    await pRetry(
+        () => postAuthFormData(`/storage${storagePath}`, {}, files, { 'X-Asset-Encoding': 'gzip' }),
+        { retries: DEFAULT_REQUEST_RETRY, factor: 1 }
+    );
+    return storagePath;
 }
 
 const uploadRunDataArtifact = _.memoize(async (projectId, testId, testResultId, runData) => {
@@ -530,6 +555,7 @@ function updateRemoteRunFailure(body) {
 }
 
 module.exports = {
+    getAppDetails,
     getS3Artifact,
     getTestPlan,
     saveTestPlanResult,
@@ -553,7 +579,7 @@ module.exports = {
     saveRemoteStep,
     getEditorUrl,
     getLabFeaturesByProjectId,
-    uploadRunDataArtifact: Promise.method(uploadRunDataArtifact),
+    uploadRunDataArtifact,
     updateTestDataArtifact: Promise.method(updateTestDataArtifact),
     initializeUserWithAuth,
     addTestRetry,

package/credentialsManager.js

@@ -5,6 +5,7 @@ const path = require('path');
 const Promise = require('bluebird');
 const YAML = require('yaml');
 const os = require('os');
+const utils = require('./utils');
 const { launchChrome } = require('./commons/chrome-launcher');
 
 async function getProjectId() {
@@ -17,7 +18,7 @@ async function getToken() {
 
 function timeout(promise, ms) {
     // we need this to time out even if we disabled timeouts system wide
-    return Promise.race([promise, Promise.delay(ms).then(() => { throw new Promise.TimeoutError('timeout'); })]);
+    return Promise.race([promise, utils.delay(ms).then(() => { throw new utils.TimeoutError('timeout'); })]);
 }
 
 async function getCredentialsFromChrome() {
@@ -73,14 +74,14 @@ async function doLogin({ overwriteExisting = true, projects = null } = {}) {
         projects = await timeout(Promise.resolve(getCredentialsFromChrome()), 62000).catch(e => null);
     }
 
-    if (projects && projects.token) { // V1(legacy) of the login extension API
+    if (projects?.token) { // V1(legacy) of the login extension API
         credentials.token = projects.token;
         credentials.projectId = projects.projectId;
         spinner.succeed();
 
         await writeCredentials(testimCredentialsFile, credentials);
         return;
-    } if (projects && projects.length) { // V2(current) of the login extension API
+    } if (projects?.length) { // V2(current) of the login extension API
         spinner.succeed();
 
         const response = projects.length === 1 ?