@testim/testim-cli 3.253.0 → 3.254.0

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');

package/commons/testimServicesApi.js

@@ -6,7 +6,7 @@ const _ = require('lodash');
 const testimCustomToken = require('./testimCustomToken');
 const constants = require('./constants');
 const Promise = require('bluebird');
-const utils = require('../utils.js');
+const utils = require('../utils');
 const config = require('./config');
 const httpRequest = require('./httpRequest');
 
@@ -84,6 +84,12 @@ function getTestPlan(projectId, testPlanNames) {
         }));
 }
 
+async function loadSfdcCredential({ branch, projectId }) {
+    const branchData = await pRetry(() => getWithAuth(`/branch/branchData/${branch}`, {
+        projectId,
+    }), { retries: DEFAULT_REQUEST_RETRY });
+    return branchData?.sfdcCredential;
+}
 
 function loadTest({ testId, branch, projectId, skipSharedSteps = false, useBranchMap = true }) {
     return pRetry(() => getWithAuth(`/test/${testId}`, {
@@ -174,7 +180,7 @@ function reportExecutionFinished(status, executionId, projectId, success, tmsOpt
         tmsOptions,
         remoteRunId,
         resultExtraData,
-    }), { reties: DEFAULT_REQUEST_RETRY });
+    }), { retries: DEFAULT_REQUEST_RETRY });
 }
 
 async function getTestPlanTestList(projectId, names, planIds, branch, intersections) {
@@ -183,7 +189,7 @@ async function getTestPlanTestList(projectId, names, planIds, branch, intersecti
         body: { projectId, names, planIds, branch, intersections },
         // people who send insane lists get a timeout :(
         timeout: 120000,
-    }), { reties: DEFAULT_REQUEST_RETRY });
+    }), { retries: DEFAULT_REQUEST_RETRY });
 }
 
 function getSuiteTestList({
@@ -204,11 +210,11 @@ function getSuiteTestList({
             testConfigIds,
             intersections,
         },
-    }), { reties: DEFAULT_REQUEST_RETRY });
+    }), { retries: DEFAULT_REQUEST_RETRY });
 }
 
 function getUsageForCurrentBillingPeriod(projectId) {
-    return pRetry(() => getWithAuth(`/plan/project/${projectId}/usage-current-billing-period`), { reties: DEFAULT_REQUEST_RETRY })
+    return pRetry(() => getWithAuth(`/plan/project/${projectId}/usage-current-billing-period`), { retries: DEFAULT_REQUEST_RETRY })
         .catch((error) => {
             logger.error('failed getting usage for current billing period', { projectId, error });
             return undefined;
@@ -216,11 +222,11 @@ function getUsageForCurrentBillingPeriod(projectId) {
 }
 
 function isTestResultCompleted(resultId, projectId, testRetryKey) {
-    return pRetry(() => getWithAuth(`/result/${resultId}/isComplete`, { projectId, testRetryKey }), { reties: DEFAULT_REQUEST_RETRY });
+    return pRetry(() => getWithAuth(`/result/${resultId}/isComplete`, { projectId, testRetryKey }), { retries: DEFAULT_REQUEST_RETRY });
 }
 
 function getTestResults(testId, resultId, projectId, branch) {
-    return pRetry(() => getWithAuth(`/test/v2/${testId}/result/${resultId}`, { projectId, branch }), { reties: DEFAULT_REQUEST_RETRY });
+    return pRetry(() => getWithAuth(`/test/v2/${testId}/result/${resultId}`, { projectId, branch }), { retries: DEFAULT_REQUEST_RETRY });
 }
 
 function keepAliveGrid(projectId, slots) {
@@ -250,11 +256,11 @@ function getHybridGridProvider(body) {
 function getGridByName(companyId, projectId, gridName, browser, executionId) {
     return pRetry(() => getWithAuth('/grid/name', {
         companyId, projectId, name: gridName, browser, executionId, reqId: utils.guid(),
-    }), { reties: DEFAULT_REQUEST_RETRY });
+    }), { retries: DEFAULT_REQUEST_RETRY });
 }
 
 function getGridById(companyId, projectId, gridId, browser, executionId) {
-    return pRetry(() => getWithAuth(`/grid/${gridId}`, { companyId, projectId, browser, executionId, reqId: utils.guid() }), { reties: DEFAULT_REQUEST_RETRY });
+    return pRetry(() => getWithAuth(`/grid/${gridId}`, { companyId, projectId, browser, executionId, reqId: utils.guid() }), { retries: DEFAULT_REQUEST_RETRY });
 }
 
 
@@ -269,7 +275,7 @@ async function initializeUserWithAuth({ projectId, token, branchName, lightweigh
                 lightweightMode,
                 localGrid,
             },
-        }), { reties: DEFAULT_REQUEST_RETRY });
+        }), { retries: DEFAULT_REQUEST_RETRY });
     } catch (e) {
         logger.error('error initializing info from server', e);
         if (e && e.message && e.message.includes('Bad Request')) {
@@ -292,7 +298,7 @@ async function getEditorUrl() {
     }
     try {
         return await pRetry(() => getWithAuth('/system-info/editor-url'), {
-            reties: DEFAULT_REQUEST_RETRY,
+            retries: DEFAULT_REQUEST_RETRY,
             onFailedAttempt: error => {
                 if (error.attemptNumber >= DEFAULT_REQUEST_RETRY) {
                     throw error;
@@ -306,16 +312,16 @@ async function getEditorUrl() {
 }
 
 function getAllGrids(companyId) {
-    return pRetry(() => getWithAuth('/grid', { companyId }), { reties: DEFAULT_REQUEST_RETRY });
+    return pRetry(() => getWithAuth('/grid', { companyId }), { retries: DEFAULT_REQUEST_RETRY });
 }
 
-const fetchLambdatestConfig = async () => pRetry(() => getWithAuth('/grid/lt/config'), { reties: DEFAULT_REQUEST_RETRY });
+const fetchLambdatestConfig = async () => pRetry(() => getWithAuth('/grid/lt/config'), { retries: DEFAULT_REQUEST_RETRY });
 
-const getLabFeaturesByProjectId = async (projectId) => pRetry(() => getWithAuth(`/labFeature/v2/project/${projectId}`), { reties: DEFAULT_REQUEST_RETRY });
+const getLabFeaturesByProjectId = async (projectId) => pRetry(() => getWithAuth(`/labFeature/v2/project/${projectId}`), { retries: DEFAULT_REQUEST_RETRY });
 
 
 function getRealData(projectId, channel, query) {
-    return pRetry(() => getWithAuth(`/real-data/${channel}?${query}&projectId=${projectId}`), { reties: DEFAULT_REQUEST_RETRY });
+    return pRetry(() => getWithAuth(`/real-data/${channel}?${query}&projectId=${projectId}`), { retries: DEFAULT_REQUEST_RETRY });
 }
 
 function updateTestResult(projectId, resultId, testId, testResult, remoteRunId) {
@@ -328,7 +334,7 @@ function updateTestResult(projectId, resultId, testId, testResult, remoteRunId)
             testResult,
             remoteRunId,
         },
-    }), { reties: DEFAULT_REQUEST_RETRY });
+    }), { retries: DEFAULT_REQUEST_RETRY });
 }
 
 function clearTestResult(projectId, resultId, testId, testResult) {
@@ -340,7 +346,7 @@ function clearTestResult(projectId, resultId, testId, testResult) {
             testId,
             testResult,
         },
-    }), { reties: DEFAULT_REQUEST_RETRY });
+    }), { retries: DEFAULT_REQUEST_RETRY });
 }
 
 function saveRemoteStep(projectId, resultId, stepId, remoteStep) {
@@ -352,7 +358,7 @@ function saveRemoteStep(projectId, resultId, stepId, remoteStep) {
             stepId,
             remoteStep,
         },
-    }), { reties: DEFAULT_REQUEST_RETRY });
+    }), { retries: DEFAULT_REQUEST_RETRY });
 }
 
 function relativize(uri) {
@@ -393,7 +399,7 @@ function uploadArtifact(projectId, testId, testResultId, content, subType, mimeT
 
     return pRetry(() => postAuthFormData(`/storage${storagePath}`, {}, files, {
         'X-Asset-Encoding': 'gzip',
-    }), { reties: DEFAULT_REQUEST_RETRY }).then(() => storagePath);
+    }), { retries: DEFAULT_REQUEST_RETRY }).then(() => storagePath);
 }
 
 const uploadRunDataArtifact = _.memoize(async (projectId, testId, testResultId, runData) => {
@@ -443,7 +449,7 @@ function addTestRetry({
             runId,
             testResult,
         },
-    }), { reties: DEFAULT_REQUEST_RETRY });
+    }), { retries: DEFAULT_REQUEST_RETRY });
 }
 
 /**
@@ -518,6 +524,7 @@ module.exports = {
     initializeUserWithAuth: Promise.method(initializeUserWithAuth),
     addTestRetry,
     getHybridGridProvider,
+    loadSfdcCredential,
     loadTest,
     isTestResultCompleted,
     getApplitoolsIntegrationData,