@testim/testim-cli 3.253.0 → 3.255.0

package/commons/runnerFileCache.js

@@ -96,7 +96,7 @@ function memoize(fn, fnName, duration = THREE_HOURS, parameters = undefined) {
         }
         logger.debug('cache miss:', { fnName });
         if (!cacheMissAllowed) {
-            throw new Error(`Attemped to rebuild cache for ${originalFnName}. cache miss is not allowed with current run configuration`);
+            throw new Error(`Attempted to rebuild cache for ${originalFnName}. cache miss is not allowed with current run configuration`);
         }
         const value = await fn();
         if (value) {

package/commons/socket/baseSocketServiceSocketIO.js

@@ -1,4 +1,4 @@
-"use strict";
+'use strict';
 
 const Promise = require('bluebird');
 const pRetry = require('p-retry');
@@ -10,22 +10,21 @@ const MAX_RECONNECT_ATTEMPT_BEFORE_SWITCH = 10;
 const EMIT_PROMISE_TIMEOUT = 5000;
 const POLLING_TRANSPORT_TIMEOUT_MS = 10 * 1000;
 
-const logger = require('../logger').getLogger("base socket service");
+const logger = require('../logger').getLogger('base socket service');
 
 class BaseSocketServiceSocketIO {
-
     constructor() {
         this.attempts = 0;
         this.rooms = {};
-        this.emitPromisQueue = undefined;
+        this.emitPromiseQueue = undefined;
     }
 
     joinToMultipleResults() {
         const testResultIds = Object.keys(this.rooms);
-        logger.info("re-join all existing rooms", {testResultIds});
-        testResultIds.map(resultId => {
+        logger.info('re-join all existing rooms', { testResultIds });
+        testResultIds.forEach(resultId => {
             const testId = this.rooms[resultId];
-            this.emitJoinRoom && this.emitJoinRoom(resultId, testId);
+            this.emitJoinRoom?.(resultId, testId);
         });
     }
 
@@ -43,20 +42,22 @@ class BaseSocketServiceSocketIO {
             try {
                 transport = this._socket.io.engine.transport.name;
             } catch (e) {
+                /* empty */
             }
-            logger.error(`Error in SocketService websocket _${method}_ socket ${this._socket.id} is ${this.url} over ${transport}. Reconnect attempts ${this.attempts}. Error is: ${err && err.message}`);
+            logger.error(`Error in SocketService websocket _${method}_ socket ${this._socket.id} ` +
+            `is ${this.url} over ${transport}. Reconnect attempts ${this.attempts}. Error is: ${err?.message}`);
         };
 
         this._socket.on('reconnect_attempt', (attempt) => {
-            socketError('reconnect_attempt', {message: 'reconnect attempt', attempt});
+            socketError('reconnect_attempt', { message: 'reconnect attempt', attempt });
             this.attempts++;
             if (this.attempts === MAX_RECONNECT_ATTEMPT_BEFORE_SWITCH && !this.isAllowedWS) {
                 this._socket.io.opts.transports = ['polling'];
                 this._socket.io.opts.upgrade = false;
             }
             if (this.attempts >= MAX_SOCKET_RECONNECT_ATTEMPT) {
-                throw new Error("Can't connect to Testim Servers.\n" +
-                    "Action required: Please allow opening a websockets connection to " + config.SERVICES_HOST + " in your firewall/proxy");
+                throw new Error('Can\'t connect to Testim Servers.\n' +
+                    `Action required: Please allow opening a websockets connection to ${config.SERVICES_HOST} in your firewall/proxy`);
             }
         });
 
@@ -81,14 +82,14 @@ class BaseSocketServiceSocketIO {
         });
 
         this._socket.on('reconnect', () => {
-            logger.info(`reconnect to socket and re-join to rooms`);
+            logger.info('reconnect to socket and re-join to rooms');
             this.joinToMultipleResults();
         });
 
         this._socket.on('connect', () => {
             this.attempts = 0;
-            if(this.isAllowedWS === undefined) {
-                this.isAllowedWS = this._socket.io.engine.transport && this._socket.io.engine.transport.name === "websocket";
+            if (this.isAllowedWS === undefined) {
+                this.isAllowedWS = this._socket.io.engine.transport && this._socket.io.engine.transport.name === 'websocket';
             }
             if (this.onConnect) {
                 this.onConnect();
@@ -98,7 +99,7 @@ class BaseSocketServiceSocketIO {
 
     initNewSocket(projectId, ns) {
         const opts = {
-            query: {'projectId': projectId},
+            query: { projectId },
             requestTimeout: POLLING_TRANSPORT_TIMEOUT_MS,
             transports: ['websocket'],
             upgrade: false,
@@ -125,7 +126,7 @@ class BaseSocketServiceSocketIO {
 
     init(projectId, ns) {
         const opts = {
-            query: {'projectId': projectId},
+            query: { projectId },
             requestTimeout: POLLING_TRANSPORT_TIMEOUT_MS,
             transports: ['websocket'],
             upgrade: false,
@@ -136,7 +137,7 @@ class BaseSocketServiceSocketIO {
             opts.ca = global.caFileContent;
         }
 
-        if(global.proxyUri) {
+        if (global.proxyUri) {
             opts.agent = new global.ProxyAgent(global.proxyUri);
         }
 
@@ -146,23 +147,20 @@ class BaseSocketServiceSocketIO {
     }
 
     emitPromise(eventName, eventData) {
-        let errorneousEvents = {};
-
-        const emitAndWait = () => {
-            return new Promise((resolve, reject) => {
-                this._socket.emit(eventName, eventData, data => {
-                    if (data && data.success) {
-                        return resolve();
-                    } else {
-                        errorneousEvents[eventName] = eventData;
-
-                        return reject(new Error("bad ack"));
-                    }
-                });
-            }).timeout(EMIT_PROMISE_TIMEOUT);
-        };
+        const errorneousEvents = {};
+
+        const emitAndWait = () => new Promise((resolve, reject) => {
+            this._socket.emit(eventName, eventData, data => {
+                if (data?.success) {
+                    return resolve();
+                }
+                errorneousEvents[eventName] = eventData;
+
+                return reject(new Error('bad ack'));
+            });
+        }).timeout(EMIT_PROMISE_TIMEOUT);
 
-        this.emitPromisQueue = (this.emitPromisQueue || Promise.resolve())
+        this.emitPromiseQueue = (this.emitPromiseQueue || Promise.resolve())
             .then(() => pRetry(emitAndWait, { retries: 200, minTimeout: 3000 }))
             .finally(() => {
                 if (Object.keys(errorneousEvents).length > 0) {
@@ -170,7 +168,7 @@ class BaseSocketServiceSocketIO {
                 }
             });
 
-        return this.emitPromisQueue;
+        return this.emitPromiseQueue;
     }
 }
 

package/commons/socket/realDataService.js

@@ -1,12 +1,12 @@
-"use strict";
+'use strict';
 
 const RealDataServiceSocketIO = require('./realDataServiceSocketIO');
 const socketService = require('./socketService');
 
-const {socketEventTypes} = require('../constants');
+const { socketEventTypes } = require('../constants');
 const featureFlags = require('../featureFlags');
 
-const {TEST_RESULT_CREATED, TEST_RESULT_UPDATED} = socketEventTypes;
+const { TEST_RESULT_CREATED, TEST_RESULT_UPDATED } = socketEventTypes;
 
 class RealDataService {
     constructor() {
@@ -25,12 +25,13 @@ class RealDataService {
 
     joinToTestResultsByRunId(runId, projectId) {
         if (featureFlags.flags.useNewWSCLI.isEnabled()) {
-            return socketService.addFilter(runId, {runId}, [
+            return socketService.addFilter(runId, { runId }, [
                 TEST_RESULT_UPDATED,
-                TEST_RESULT_CREATED
+                TEST_RESULT_CREATED,
             ], true);
         }
         this.realDataServiceSocketIO.joinToTestResultsByRunId(runId, projectId);
+        return undefined;
     }
 
     stopListenToTestResultsByRunId(runId) {

package/commons/socket/realDataServiceSocketIO.js

@@ -1,4 +1,4 @@
-"use strict";
+'use strict';
 
 const BaseSocketService = require('./baseSocketServiceSocketIO');
 
@@ -8,7 +8,7 @@ class RealDataServiceSocketIO extends BaseSocketService {
     }
 
     emitJoinRoom(runId, projectId) {
-        this._socket.emit("testResult:listen", {query: `projectId=${projectId}&runId=${runId}`});
+        this._socket.emit('testResult:listen', { query: `projectId=${projectId}&runId=${runId}` });
     }
 
     joinToTestResultsByRunId(runId, projectId) {
@@ -18,7 +18,7 @@ class RealDataServiceSocketIO extends BaseSocketService {
 
     stopListenToTestResultsByRunId(runId) {
         this.leaveRoom(runId);
-        this._socket.emit("testResult:listen:stop", {});
+        this._socket.emit('testResult:listen:stop', {});
     }
 
     listenToTestResultsByRunId(cb) {
@@ -26,7 +26,7 @@ class RealDataServiceSocketIO extends BaseSocketService {
             cb(data.data);
         }
 
-        this._socket.on("testResult:changes", onDone.bind(this));
+        this._socket.on('testResult:changes', onDone.bind(this));
     }
 }
 

package/commons/socket/remoteStepService.js

@@ -1,8 +1,9 @@
 let remoteStepServiceSocketIO; // required lazily since it takes 150ms to load
 const socketService = require('./socketService');
 
-const {socketEventTypes} = require('../constants');
-const {REMOTE_STEP_SAVED} = socketEventTypes;
+const { socketEventTypes } = require('../constants');
+
+const { REMOTE_STEP_SAVED } = socketEventTypes;
 const featureFlags = require('../featureFlags');
 const Promise = require('bluebird');
 
@@ -17,7 +18,7 @@ class RemoteStepService {
 
     joinToRemoteStep(resultId) {
         if (featureFlags.flags.useNewWSCLI.isEnabled()) {
-            return socketService.addFilter(`${resultId}:remoteStep`, {resultId}, [REMOTE_STEP_SAVED]);
+            return socketService.addFilter(`${resultId}:remoteStep`, { resultId }, [REMOTE_STEP_SAVED]);
         }
         return remoteStepServiceSocketIO.joinToRemoteStep(resultId);
     }

package/commons/socket/remoteStepServiceSocketIO.js

@@ -1,4 +1,4 @@
-"use strict";
+'use strict';
 
 const Promise = require('bluebird');
 const BaseSocketService = require('./baseSocketServiceSocketIO');
@@ -10,15 +10,15 @@ class RemoteStepServiceSocketIO extends BaseSocketService {
     }
 
     emitJoinRoom(resultId) {
-        return this.emitPromise("remoteStep:join", {resultId});
+        return this.emitPromise('remoteStep:join', { resultId });
     }
 
     emitLeaveRoom(resultId) {
-        return this.emitPromise("remoteStep:leave", {resultId});
+        return this.emitPromise('remoteStep:leave', { resultId });
     }
 
     joinToRemoteStep(resultId) {
-        if(this.rooms[resultId]) {
+        if (this.rooms[resultId]) {
             return Promise.resolve();
         }
         this.joinRoom(resultId);
@@ -26,17 +26,16 @@ class RemoteStepServiceSocketIO extends BaseSocketService {
     }
 
     saveRemoteStep(resultId, stepId, remoteStep) {
-        return this.emitPromise("remoteStep:save", {
+        return this.emitPromise('remoteStep:save', {
             resultId,
             stepId,
-            remoteStep
+            remoteStep,
         });
     }
 
     listenToRemoteStep(resultId, onRemoteStep) {
-
-        if(this.listerers[resultId]) {
-            this._socket.off("remoteStep:saved", this.listerers[resultId]);
+        if (this.listerers[resultId]) {
+            this._socket.off('remoteStep:saved', this.listerers[resultId]);
             delete this.listerers[resultId];
         }
 
@@ -45,16 +44,16 @@ class RemoteStepServiceSocketIO extends BaseSocketService {
                 onRemoteStep(data.remoteStep);
             }
         };
-        this._socket.on("remoteStep:saved", this.listerers[resultId]);
+        this._socket.on('remoteStep:saved', this.listerers[resultId]);
     }
 
     unlistenToRemoteStep(resultId) {
-        if(!this.listerers[resultId]) {
+        if (!this.listerers[resultId]) {
             return Promise.resolve();
         }
 
         this.leaveRoom(resultId);
-        this._socket.off("remoteStep:saved", this.listerers[resultId]);
+        this._socket.off('remoteStep:saved', this.listerers[resultId]);
         delete this.listerers[resultId];
         return this.emitLeaveRoom(resultId);
     }

package/commons/socket/socketService.js

@@ -1,10 +1,10 @@
-"use strict";
+'use strict';
 
 const WebSocket = require('ws');
-const {WEBSOCKET_HOST} = require('../config');
+const { WEBSOCKET_HOST } = require('../config');
 const utils = require('../../utils');
-const logger = require('../logger').getLogger("socket-ng-service");
-const {EventEmitter} = require('events');
+const logger = require('../logger').getLogger('socket-ng-service');
+const { EventEmitter } = require('events');
 const _ = require('lodash');
 const Promise = require('bluebird');
 const testimCustomToken = require('../testimCustomToken');
@@ -21,16 +21,16 @@ class SocketService extends EventEmitter {
     }
 
     onReconnect(projectId) {
-        logger.info(`test result websocket re-connect`);
+        logger.info('test result websocket re-connect');
         setTimeout(() => this.connect(projectId), WAIT_BETWEEN_RECONNECT_MS);
     }
 
     formatUrl(url) {
-        if(_.startsWith(url, "http://")) {
+        if (_.startsWith(url, 'http://')) {
             return _.replace(url, 'http://', 'ws://');
         }
 
-        if(_.startsWith(url, "https://")) {
+        if (_.startsWith(url, 'https://')) {
             return _.replace(url, 'https://', 'wss://');
         }
 
@@ -41,50 +41,48 @@ class SocketService extends EventEmitter {
         try {
             return JSON.parse(event);
         } catch (err) {
-            logger.error(`failed to parse or trigger event`, {err});
+            logger.error('failed to parse or trigger event', { err });
         }
+        return undefined;
     }
 
-
     connect(projectId) {
         const wsBaseUrl = this.formatUrl(WEBSOCKET_HOST);
         return testimCustomToken.getCustomTokenV3()
-            .then(token => {
-                return new Promise((resolve) => {
-                    const options = {};
-                    if(global.proxyUri) {
-                        options.agent = new global.ProxyAgent(global.proxyUri);
+            .then(token => new Promise((resolve) => {
+                const options = {};
+                if (global.proxyUri) {
+                    options.agent = new global.ProxyAgent(global.proxyUri);
+                }
+                this.ws = new WebSocket(`${wsBaseUrl}?projectId=${projectId}&clientId=${this.clientId}&token=${token}`, options);
+
+                this.ws.on('open', () => {
+                    logger.info('websocket opened');
+                    this.reSendAllExistingFilters();
+                    if (this.onConnect) {
+                        this.onConnect();
+                    }
+                    return resolve();
+                });
+
+                this.ws.on('close', (event) => {
+                    logger.info('websocket closed', { event });
+                    if (!this.ws || this.ws.readyState === WebSocket.CLOSED) {
+                        this.onReconnect(projectId, token, wsBaseUrl);
+                    }
+                });
+
+                this.ws.on('error', (event) => {
+                    logger.info('websocket error', { event });
+                });
+
+                this.ws.on('message', (event) => {
+                    const evObject = this.parseEvent(event);
+                    if (evObject?.type) {
+                        this.emit(evObject.type, evObject.data);
                     }
-                    this.ws = new WebSocket(`${wsBaseUrl}?projectId=${projectId}&clientId=${this.clientId}&token=${token}`, options);
-
-                    this.ws.on("open", () => {
-                        logger.info(`websocket opened`);
-                        this.reSendAllExistingFilters();
-                        if (this.onConnect) {
-                            this.onConnect();
-                        }
-                        return resolve();
-                    });
-
-                    this.ws.on("close", (event) => {
-                        logger.info(`websocket closed`, {event});
-                        if (!this.ws || this.ws.readyState === WebSocket.CLOSED) {
-                            this.onReconnect(projectId, token, wsBaseUrl);
-                        }
-                    });
-
-                    this.ws.on("error", (event) => {
-                        logger.info(`websocket error`, {event});
-                    });
-
-                    this.ws.on("message", (event) => {
-                        const evObject = this.parseEvent(event);
-                        if (evObject && evObject.type) {
-                            this.emit(evObject.type, evObject.data);
-                        }
-                    });
                 });
-            });
+            }));
     }
 
     // this is private because our sockets are supposed to be read-only to
@@ -99,7 +97,7 @@ class SocketService extends EventEmitter {
         try {
             this.ws.send(JSON.stringify(msg));
         } catch (err) {
-            logger.error('failed to stringify message for sending', {err});
+            logger.error('failed to stringify message for sending', { err });
         }
     }
 
@@ -125,25 +123,25 @@ class SocketService extends EventEmitter {
         const eventNameArray = Array.isArray(eventName) ? eventName : [eventName];
         eventNameArray.forEach(name => {
             this.listeners[`${key}:${name}`] = this.listeners[`${key}:${name}`] || [];
-            const listener = fireIfSameMatchEventMatcher.bind(this);
-            this.listeners[`${key}:${name}`].push(listener);
-            this.on(name, listener);
+            const _listener = fireIfSameMatchEventMatcher.bind(this);
+            this.listeners[`${key}:${name}`].push(_listener);
+            this.on(name, _listener);
         });
     }
 
     reSendAllExistingFilters() {
         Object.keys(this.filterMap).forEach(key => {
             const filter = this.filterMap[key];
-            this.sendMessage({type: "add-filter", filter});
+            this.sendMessage({ type: 'add-filter', filter });
         });
     }
 
     addFilter(key, query, type, returnFullDocument = false) {
         return new Promise(resolve => {
             const filterId = utils.guid();
-            const filter = {query, id: filterId, type, fullDocument: returnFullDocument};
-            this.listenOnce("add-filter:done", data => data.id === filterId, resolve);
-            this.sendMessage({type: "add-filter", filter});
+            const filter = { query, id: filterId, type, fullDocument: returnFullDocument };
+            this.listenOnce('add-filter:done', data => data.id === filterId, resolve);
+            this.sendMessage({ type: 'add-filter', filter });
             this.filterMap[key] = filter;
         });
     }
@@ -170,7 +168,7 @@ class SocketService extends EventEmitter {
         const typeArray = Array.isArray(type) ? type : [type];
         this.removeListeners(key, typeArray);
         delete this.filterMap[key];
-        this.sendMessage({type: "remove-filter", filter});
+        this.sendMessage({ type: 'remove-filter', filter });
     }
 }
 

package/commons/socket/testResultServiceSocketIO.js

@@ -1,4 +1,4 @@
-"use strict";
+'use strict';
 
 const Promise = require('bluebird');
 const BaseSocketService = require('./baseSocketServiceSocketIO');
@@ -10,8 +10,8 @@ class TestResultServiceSocketIO extends BaseSocketService {
     }
 
     listenToTestResult(resultId, testId, onTestResultStatus) {
-        if(this.listerers[resultId]) {
-            this._socket.off("testResult:updated", this.listerers[resultId]);
+        if (this.listerers[resultId]) {
+            this._socket.off('testResult:updated', this.listerers[resultId]);
             delete this.listerers[resultId];
         }
 
@@ -21,18 +21,18 @@ class TestResultServiceSocketIO extends BaseSocketService {
             }
         };
 
-        this._socket.on("testResult:updated", this.listerers[resultId]);
+        this._socket.on('testResult:updated', this.listerers[resultId]);
     }
 
     emitJoinRoom(resultId, testId) {
-        return this.emitPromise("testResult:join", {
+        return this.emitPromise('testResult:join', {
             resultId,
-            testId
+            testId,
         });
     }
 
     joinToTestResult(resultId, testId) {
-        if(this.rooms[resultId]) {
+        if (this.rooms[resultId]) {
             return Promise.resolve();
         }
         this.joinRoom(resultId, testId);
@@ -40,19 +40,19 @@ class TestResultServiceSocketIO extends BaseSocketService {
     }
 
     emitLeaveRoom(resultId, testId) {
-        return this.emitPromise("testResult:leave", {
+        return this.emitPromise('testResult:leave', {
             resultId,
-            testId
+            testId,
         });
     }
 
     leaveTestResult(resultId, testId) {
-        if(!this.listerers[resultId]) {
+        if (!this.listerers[resultId]) {
             return Promise.resolve();
         }
 
         this.leaveRoom(resultId);
-        this._socket.off("testResult:updated", this.listerers[resultId]);
+        this._socket.off('testResult:updated', this.listerers[resultId]);
         delete this.listerers[resultId];
         return this.emitLeaveRoom(resultId, testId);
     }

package/commons/testimDesiredCapabilitiesBuilder.js

@@ -628,9 +628,10 @@ function buildAppiumOptions({ projectType, gridInfo, testRunConfig, nativeApp })
             break;
         case 'android':
             appCaps = {
-                appPackage: nativeApp.packageName,
-                appActivity: nativeApp.activity,
+                platformName: 'Android',
                 'appium:automationName': 'UiAutomator2',
+                'appium:appPackage': nativeApp.packageName,
+                'appium:appActivity': nativeApp.activity,
             };
             break;
         default:

package/commons/testimNgrok.js

@@ -1,7 +1,7 @@
 'use strict';
 
-const { ArgError } = require('../errors.js');
-const utils = require('../utils.js');
+const { ArgError } = require('../errors');
+const utils = require('../utils');
 const lazyRequire = require('./lazyRequire');
 const logger = require('./logger').getLogger('testimNgrok');
 

package/commons/testimNgrok.test.js

@@ -2,7 +2,7 @@
 
 'use strict';
 
-const { ArgError } = require('../errors.js');
+const { ArgError } = require('../errors');
 const { sinon, expect } = require('../../test/utils/testUtils');
 const testimNgrok = require('./testimNgrok');
 const utils = require('../utils');