@testim/testim-cli 3.255.0 → 3.257.0

package/agent/routers/cliJsCode/service.js

@@ -40,10 +40,6 @@ function runCode(transactionId, incomingParams, context, code, packageLocalLocat
         return all;
     }, '');
 
-    if (fileDataUrl === 'data:') { // fix chrome/safari bug that creates malformed datauri for empty files
-        fileDataUrl = 'data:,';
-    }
-
     const fileDataUrlToFileBuffer = !fileDataUrl ? 'var fileBuffer = null;' :
         `
             ${dataUriToBuffer.toString()}
@@ -297,10 +293,6 @@ function runCodeWithWorkerThread(transactionId, incomingParams, context, code, p
         return all;
     }, '');
 
-    if (fileDataUrl === 'data:') { // fix chrome/safari bug that creates malformed datauri for empty files
-        fileDataUrl = 'data:,';
-    }
-
     const fileDataUrlToFileBuffer = !fileDataUrl ? 'var fileBuffer = null;' :
         `
             ${dataUriToBuffer.toString()}
@@ -581,6 +573,17 @@ function runCodeWithPackages(code, stepId, incomingParams, context, testResultId
             }
         }
 
+        if (Buffer.isBuffer(fileDataUrl)) { // Fix, S3 is returning a buffer and not a string on empty files
+            logger.debug('runCodeWithPackages: converted a buffer to base 64 string data URI', { fileDataUrl });
+            fileDataUrl = fileDataUrl.toString();
+        }
+
+        const emptyFileDataUrl = 'data:,';
+        if (fileDataUrl === 'data:') { // Fix chrome/safari bug that creates malformed data-uri for empty files
+            logger.debug('runCodeWithPackages, fileDataUrl was an empty string ', { fileDataUrl });
+            fileDataUrl = emptyFileDataUrl;
+        }
+
         if (workerThreads && featureFlags.flags.enableWorkerThreadsCliCodeExecution.isEnabled()) {
             return runCodeWithWorkerThread(transactionId, incomingParams, context, code, packageLocalLocations, timeout, fileDataUrl);
         }

package/cli.js

@@ -85,9 +85,9 @@ async function main() {
             }
             const res = await runnerFileCache.waitForSave();
             if (res.success) {
-                console.log(`created prefeched data at ${runnerFileCache.getCacheFileLocation()}`);
+                console.log(`created prefetched data at ${runnerFileCache.getCacheFileLocation()}`);
             } else {
-                console.error('failed to create prefech data', res.error);
+                console.error('failed to create prefetch data', res.error);
             }
             return undefined;
         }

package/cliAgentMode.js

@@ -39,10 +39,7 @@ function shouldStartAgentMode(options) {
     return options.agentMode;
 }
 
-/**
- *
- * @param {*} options
- */
+/** @param {import('./runOptions').AgentModeOptions} options */
 async function runAgentMode(options) {
     let testimStandaloneBrowser;
 
@@ -169,6 +166,7 @@ async function startFixedVersionChromium(options, extensionBase64, downloadedExt
     };
 }
 
+/** @param {import('./runOptions').AgentModeOptions} options */
 async function startTestimStandaloneBrowser(options) {
     // After next clickim release we will have also testim-full.zip
     // const fullExtensionUrl = "https://testimstatic.blob.core.windows.net/extension/testim-full-master.zip";
@@ -222,9 +220,11 @@ async function startTestimStandaloneBrowser(options) {
     }
     await prepareUtils.prepareChromeDriver(
         { projectId: options.project },
+        // @ts-expect-error not clear where chromeBinaryLocations comes from
         { chromeBinaryLocation: options.chromeBinaryLocations },
     );
 
+    // @ts-expect-error not clear where chromeBinaryLocations comes from
     const seleniumOptions = buildSeleniumOptions(USER_DATA_DIR, extensionBase64, options.extensionPath, options.chromeBinaryLocations);
 
     const WebDriver = require('./player/webdriver');
@@ -264,7 +264,7 @@ async function startTestimStandaloneBrowser(options) {
 
 /**
  * @param {string} userDataDir
- * @param {string} fullExtensionPath
+ * @param {string | null} fullExtensionPath
  */
 function buildSeleniumOptions(userDataDir, fullExtensionPath, unpackedExtensionPath, chromeBinaryPath) {
     const extensions = fullExtensionPath ? [fullExtensionPath] : [];
@@ -356,7 +356,7 @@ async function readAndValidateChromedriverDevToolsActivePortFile() {
 
 /**
  * @param {string | import("url").URL} webSocketDebuggerUrl
- * @param {number?} timeout
+ * @param {number=} timeout
  */
 async function tryToCloseBrowserWithCDPUrl(webSocketDebuggerUrl, timeout = 100) {
     const websocketConnection = await wsConnectAndOpen(webSocketDebuggerUrl, timeout);
@@ -371,7 +371,7 @@ async function tryToCloseBrowserWithCDPUrl(webSocketDebuggerUrl, timeout = 100)
 
 /**
  * @param {string | import("url").URL} webSocketDebuggerUrl
- * @param {number?} timeout
+ * @param {number=} timeout
  */
 async function wsConnectAndOpen(webSocketDebuggerUrl, timeout = 100) {
     const websocket = new WebSocket(webSocketDebuggerUrl, { timeout });

package/codim/codim-cli.js

@@ -1,3 +1,5 @@
+// @ts-check
+
 /* eslint-disable no-console */
 
 'use strict';
@@ -6,11 +8,12 @@ const fs = require('fs');
 const childProcess = require('child_process');
 const path = require('path');
 const validateNpmPackageName = require('validate-npm-package-name');
-const ArgError = require('../errors.js').ArgError;
 const { promisify } = require('util');
+const { ArgError } = require('../errors.js');
 
 const exec = promisify(childProcess.exec);
 
+/** @param {string} name */
 module.exports.init = async function init(name) {
     const ora = require('ora');
     const prompts = require('prompts');

package/commons/featureFlags.js

@@ -1,9 +1,11 @@
 'use strict';
 
-const { ROLLOUT_KEY, IS_ON_PREM, GATEWAY_URL } = require('./config');
-const logger = require('./logger').getLogger('FeatureFlagsService');
-const Promise = require('bluebird');
 const Rox = require('rox-node');
+const { getLogger } = require('./logger');
+const { promiseTimeout } = require('../utils');
+const { ROLLOUT_KEY, IS_ON_PREM, GATEWAY_URL } = require('./config');
+
+const logger = getLogger('FeatureFlagsService');
 
 // IS_UNIT_TEST = disable rollout if code run in unit test mode to ignore mocha process stuck on running
 const USE_FEATURE_FLAGS = !IS_ON_PREM && !process.env.IS_UNIT_TEST && !GATEWAY_URL;
@@ -11,6 +13,7 @@ const USE_FEATURE_FLAGS = !IS_ON_PREM && !process.env.IS_UNIT_TEST && !GATEWAY_U
 const FORCE_FETCH_TIMEOUT_MS = 20000; // rollout sometimes takes up to 15 seconds to load
 const SEC_IN_DAY = 60 * 60 * 24;
 
+/** @type {['labs', 'disabled', 'enabled'] as const} */
 const LAB_FEATURE_FLAG_VALUES = ['labs', 'disabled', 'enabled'];
 
 class LabFeatureFlag extends Rox.Variant {
@@ -18,6 +21,7 @@ class LabFeatureFlag extends Rox.Variant {
         super(initialValue, LAB_FEATURE_FLAG_VALUES);
     }
 
+    /** @returns {(typeof LAB_FEATURE_FLAG_VALUES)[number]} */
     getValue() {
         const value = super.getValue();
         if (!LAB_FEATURE_FLAG_VALUES.includes(value)) {
@@ -63,41 +67,51 @@ class FeatureFlagsService {
         Rox.register('default', this.flags);
     }
 
+    /** @param {string} projectId */
     setProjectId(projectId) {
         Rox.setCustomStringProperty('projectId', projectId);
     }
 
+    /** @param {string} projectType */
     setProjectType(projectType) {
         Rox.setCustomStringProperty('projectType', projectType);
     }
 
+    /** @param {string} productType */
     setCompanyProductType(productType) {
         Rox.setCustomStringProperty('productType', productType);
     }
 
+    /** @param {string} companyId */
     setCompanyId(companyId) {
         Rox.setCustomStringProperty('companyId', companyId);
     }
 
+    /** @param {string} planType */
     setPlanType(planType) {
         Rox.setCustomStringProperty('planType', planType);
     }
 
+    /** @param {boolean} isPOC */
     setIsPOC(isPOC) {
         Rox.setCustomBooleanProperty('isPOC', isPOC);
     }
+
+    /** @param {boolean} isStartUp */
     setIsStartUp(isStartUp) {
         Rox.setCustomBooleanProperty('isStartUp', isStartUp);
     }
 
+    /** @param {string} mode */
     setRunnerMode(mode) {
         Rox.setCustomStringProperty('runnerMode', mode);
     }
 
-    fetch() {
+    async fetch() {
         if (!USE_FEATURE_FLAGS) {
-            return Promise.resolve();
+            return undefined;
         }
+        /** @type {Rox.RoxSetupOptions} */
         const opts = {
             fetchIntervalInSec: SEC_IN_DAY, // we don't actually want to refresh feature flags in the CLI,
             disableNetworkFetch: false,
@@ -110,8 +124,8 @@ class FeatureFlagsService {
             opts.httpAgent = agent;
         }
 
-        return Promise.resolve(Rox.setup(ROLLOUT_KEY, opts))
-            .timeout(FORCE_FETCH_TIMEOUT_MS).catch(err => logger.error('failed to get feature flag status', err));
+        return promiseTimeout(Rox.setup(ROLLOUT_KEY, opts), FORCE_FETCH_TIMEOUT_MS)
+            .catch(err => logger.error('failed to get feature flag status', err));
     }
 }
 

package/commons/httpRequest.js

@@ -217,7 +217,7 @@ function put(url, body, headers = {}, timeout = DEFAULT_REQUEST_TIMEOUT) {
 
 /**
  * @param {string} url
- * @returns {Promise<superagent.Response>}
+ * @returns {Promise<Omit<superagent.Response, 'body'> & { body: Buffer }>}
  */
 function download(url) {
     logger.info('start to download', { url });

package/commons/initializeUserWithAuth.js

@@ -1,7 +1,7 @@
 
 const perf = require('./performance-logger');
 const localRunnerCache = require('./runnerFileCache');
-const servicesApi = require('./testimServicesApi.js');
+const servicesApi = require('./testimServicesApi');
 const testimCustomToken = require('./testimCustomToken');
 const { CLI_MODE } = require('./constants');
 
@@ -24,12 +24,15 @@ function preloadSlowRequires(mode) {
     });
 }
 
+/**
+ * @param {import('../runOptions').RunnerOptions} options
+ */
 async function initializeUserWithAuth(options) {
     const { project, token, lightweightMode, useLocalChromeDriver, useChromeLauncher, mode } = options;
 
-    const lightweightModeGenral = Boolean(lightweightMode && lightweightMode.general);
+    const lightweightModeGeneral = Boolean(lightweightMode?.general);
     const localGrid = Boolean(useLocalChromeDriver || useChromeLauncher);
-    const memoizationTTL = lightweightModeGenral ? TEN_HOURS_MS : FIVE_MINUTES_MS;
+    const memoizationTTL = lightweightModeGeneral ? TEN_HOURS_MS : FIVE_MINUTES_MS;
 
     perf.log('before initializeUserWithAuth');
     const result = await localRunnerCache.memoize(async () => {
@@ -41,7 +44,7 @@ async function initializeUserWithAuth(options) {
             lightweightMode,
             localGrid,
         });
-    }, 'initializeUserWithAuth', memoizationTTL, { project, token, branchName: options.branch, lightweightModeGenral, localGrid })();
+    }, 'initializeUserWithAuth', memoizationTTL, { project, token, branchName: options.branch, lightweightModeGeneral, localGrid })();
     perf.log('after initializeUserWithAuth');
 
     testimCustomToken.initFromData(result.authData, options.project, options.token);

package/commons/preloadTests.js

@@ -1,11 +1,14 @@
 const _ = require('lodash');
-const { promiseMap } = require('../utils');
 const localRunnerCache = require('./runnerFileCache');
-const servicesApi = require('./testimServicesApi.js');
+const servicesApi = require('./testimServicesApi');
+const { promiseMap } = require('../utils');
 
 
 const TEN_HOURS = 1000 * 60 * 60 * 10;
 
+/**
+ * @param {import('../runOptions').RunnerOptions} options
+ */
 async function preloadTests(options) {
     if (!Array.isArray(options.testId) || !options.testId.length) {
         return {};

package/commons/prepareRunner.js

@@ -22,6 +22,7 @@ Promise.resolve().then(() => {
     global.xhr2 = require('./xhr2'); // this is inside a `then` to not block and let network requests start
 });
 
+/** @param {import('../runOptions').RunnerOptions} options */
 async function prepare(options) {
     /**
      * @type {globalThis.Promise<void>}
@@ -61,16 +62,15 @@ async function prepare(options) {
 
 async function prepareMockNetwork(location) {
     logger.info('prepare MockNetwork', { location });
-    /** @type {Buffer} */
-    // @ts-expect-error There seems to be an actual bug in case the location is a URL.
-    const rulesJsonBuf = await utils.getSourceAsBuffer(location);
+    const _rulesJson = await utils.getSourceAsBuffer(location);
+    const rulesJsonBuf = Buffer.isBuffer(_rulesJson) ? _rulesJson : _rulesJson.body;
     if (rulesJsonBuf.byteLength > MAX_RULE_FILE_SIZE_IN_MB * 1000000) {
         throw new Error(`${PREPARE_MOCK_NETWORK_ERROR_PREFIX} exceeded ${MAX_RULE_FILE_SIZE_IN_MB}MB`);
     }
 
     let rulesJson;
     try {
-        rulesJson = JSON.parse(rulesJsonBuf);
+        rulesJson = JSON.parse(rulesJsonBuf.toString('utf-8'));
     } catch (error) {
         throw new Error(`${PREPARE_MOCK_NETWORK_ERROR_PREFIX} cannot be parsed.${os.EOL}${error}`);
     }
@@ -78,7 +78,7 @@ async function prepareMockNetwork(location) {
     const ajv = new Ajv();
     const valid = ajv.validate(mockNetworkRuleFileSchema, rulesJson);
     if (!valid) {
-        const errors = ajv.errors.map((e, i) => `${++i}) ${e.dataPath} ${e.message}`).join(os.EOL);
+        const errors = ajv.errors?.map((e, i) => `${++i}) ${e.dataPath} ${e.message}`).join(os.EOL);
         throw new Error(`${PREPARE_MOCK_NETWORK_ERROR_PREFIX} is malformed.${os.EOL}${errors}`);
     }
 

package/commons/prepareRunnerAndTestimStartUtils.js

@@ -140,7 +140,7 @@ async function getPlayerVersion() {
 
 /**
  * @param {string} location
- * @param {string | undefined} canary
+ * @param {boolean=} canary
  */
 async function getPlayerLocation(location, canary) {
     if (!isURL(location) || (isURL(location) && canary) || config.IS_ON_PREM) {
@@ -177,13 +177,20 @@ async function downloadAndUnzip(loc, playerFileName, isRetry = false) {
     }
 }
 
+/**
+ * @param {string} location
+ * @param {boolean=} canary
+ */
 async function preparePlayer(location, canary) {
     logger.info('prepare player', { location, canary });
     const playerFileName = getPlayerDestination();
     return localRunnerCache.memoize(
-        () => getPlayerLocation(location, canary)
-            .then(loc => downloadAndUnzip(loc, playerFileName))
-            .then(() => ({})),
+        async () => {
+            const loc = await getPlayerLocation(location, canary);
+            await downloadAndUnzip(loc, playerFileName);
+            // return a truthy value, so the caching has a value, and doesn't ignore
+            return {};
+        },
         'preparePlayer',
         MSEC_IN_HALF_DAY,
         [location, canary, playerFileName]

package/commons/runnerFileCache.js

@@ -79,7 +79,15 @@ function decrypt(key, buffer) {
     const decrypted = decipher.update(encryptedText);
     return JSON.parse(Buffer.concat([decrypted, decipher.final()]));
 }
-// argument less memoize for functions with a global cache name
+/**
+ * argument-less memoize for functions with a global cache name
+ * @template T
+ * @param {() => PromiseLike<T>} fn
+ * @param {string} fnName
+ * @param {number=} duration
+ * @param {*} parameters
+ * @returns {() => Promise<Awaited<T>>}
+ */
 function memoize(fn, fnName, duration = THREE_HOURS, parameters = undefined) {
     return Promise.method(async () => {
         if (!cacheEnabled) {

package/commons/testimServicesApi.js

@@ -192,6 +192,27 @@ async function getTestPlanTestList(projectId, names, planIds, branch, intersecti
     }), { retries: DEFAULT_REQUEST_RETRY });
 }
 
+/**
+ * @param {{
+ *   projectId: string;
+ *   labels: string[];
+ *   testIds: string[];
+ *   testNames: string[];
+ *   testConfigNames?: string[];
+ *   suiteNames: string[];
+ *   suiteIds: string[];
+ *   branch: string;
+ *   rerunFailedByRunId?: string;
+ *   testConfigIds?: string[];
+ *   intersections: import('../runOptions').RunnerOptions['intersections'];
+ * }} param0
+ * @returns {globalThis.Promise<{
+ *   tests: any[][];
+ *   branch?: string;
+ *   runName?: string;
+ *   runExists?: boolean;
+ * }>}
+ */
 function getSuiteTestList({
     projectId, labels, testIds, testNames, testConfigNames, suiteNames, suiteIds, branch, rerunFailedByRunId, testConfigIds, intersections,
 }) {
@@ -263,7 +284,17 @@ function getGridById(companyId, projectId, gridId, browser, executionId) {
     return pRetry(() => getWithAuth(`/grid/${gridId}`, { companyId, projectId, browser, executionId, reqId: utils.guid() }), { retries: DEFAULT_REQUEST_RETRY });
 }
 
-
+/**
+ * @param {{ projectId: string; token: string; branchName: string; lightweightMode?: import('../runOptions').LightweightSettings; localGrid: boolean; }} param0
+ * @returns {globalThis.Promise<{
+ *  authData: { token: string; refreshToken: string; uid: string; ngrokToken?: string; isNgrokWhitelisted?: boolean; };
+ *  editorConfig: { editorUrl: string };
+ *  companyByProjectId: Awaited<ReturnType<import('services/src/company/companyService')['getCompanyByProjectIdUsingCache']>>;
+ *  projectById: NonNullable<Awaited<ReturnType<import('services/src/commons/testimCache')['project']['getById']>>>;
+ *  allGrids: import('services/src/commons/mongo/models/grid').RawGrid[];
+ *  branchName: string | import('services/src/commons/mongo/models/branchesData').RawBranchesData | null;
+ * }>}
+ */
 async function initializeUserWithAuth({ projectId, token, branchName, lightweightMode, localGrid }) {
     try {
         return await pRetry(() => httpRequest.post({
@@ -278,14 +309,14 @@ async function initializeUserWithAuth({ projectId, token, branchName, lightweigh
         }), { retries: DEFAULT_REQUEST_RETRY });
     } catch (e) {
         logger.error('error initializing info from server', e);
-        if (e && e.message && e.message.includes('Bad Request')) {
+        if (e?.message?.includes('Bad Request')) {
             throw new ArgError(
                 'Error trying to retrieve CLI token. ' +
                 'Your CLI token and project might not match. ' +
                 'Please make sure to pass `--project` and `--token` that' +
                 ' match to each other or make sure they match in your ~/.testim file.');
         }
-        if (e && e.code && e.code.includes('ENOTFOUND')) {
+        if (e?.code?.includes('ENOTFOUND')) {
             throw new ArgError('Due to network connectivity issues, Testim CLI has been unable to connect to the Testim backend.');
         }
         throw e;
@@ -415,7 +446,7 @@ const updateTestDataArtifact = _.memoize(async (projectId, testId, testResultId,
     }
     const removeHiddenParamsInTestData = () => {
         const testDataValueClone = _.clone(testData);
-        if (projectDefaults && projectDefaults.hiddenParams) {
+        if (projectDefaults?.hiddenParams) {
             const { hiddenParams } = projectDefaults;
             (hiddenParams || []).forEach((param) => {
                 if (testDataValueClone[param]) {
@@ -521,7 +552,7 @@ module.exports = {
     getLabFeaturesByProjectId,
     uploadRunDataArtifact: Promise.method(uploadRunDataArtifact),
     updateTestDataArtifact: Promise.method(updateTestDataArtifact),
-    initializeUserWithAuth: Promise.method(initializeUserWithAuth),
+    initializeUserWithAuth,
     addTestRetry,
     getHybridGridProvider,
     loadSfdcCredential,