@testim/testim-cli 3.254.0 → 3.256.0

package/runners/TestPlanRunner.js

@@ -39,12 +39,13 @@ class TestPlanRunner {
      * @param {any[]} tests
      * @param {any[]} afterTests
      * @param {string} branchToUse
-     * @param {*} tpOptions
+     * @param {import('../runOptions').RunnerOptions} tpOptions
      * @param {string} executionId
      * @param {string} executionName
      * @param {TestRunStatus} testStatus
      */
     async runTestAllPhases(beforeTests, tests, afterTests, branchToUse, tpOptions, executionId, executionName, testStatus) {
+        /** @type {{ [testResultId: string]: any; }} */
         const executionResults = {};
         const authData = testimCustomToken.getTokenV3UserData();
 
@@ -71,10 +72,6 @@ class TestPlanRunner {
             Object.assign(executionResults, afterTestsResults);
         };
 
-        function catchBeforeTestsFailed() {
-            return testStatus.markAllQueuedTests(executionId, constants.runnerTestStatus.ABORTED, 'aborted', false);
-        }
-
         const sessionType = utils.getSessionType(tpOptions);
         analyticsService.analyticsExecsStart({ authData, executionId, projectId: tpOptions.project, sessionType });
         perf.log('right before runBeforeTests');
@@ -88,7 +85,7 @@ class TestPlanRunner {
         } catch (err) {
             logger.error('error running test plan', { err });
             if (err instanceof StopRunOnError) {
-                return catchBeforeTestsFailed();
+                return testStatus.markAllQueuedTests(executionId, constants.runnerTestStatus.ABORTED, 'aborted', false);
             }
             throw err;
         } finally {
@@ -149,6 +146,7 @@ class TestPlanRunner {
         const childTestResults = {};
         realDataService.joinToTestResultsByRunId(runId, projectId);
         let isPromisePending = true;
+        /** @type {Promise<any[]>} */
         const promise = new Promise(_resolve => {
             const resolve = (val) => {
                 isPromisePending = false;
@@ -218,7 +216,7 @@ class TestPlanRunner {
      * @param {any[]} beforeTests
      * @param {any[]} tests
      * @param {any[]} afterTests
-     * @param {Awaited<ReturnType<typeof import('../runOptions')['process']>>} tpOptions
+     * @param {import('../runOptions').RunnerOptions} tpOptions
      * @param {string} testPlanName
      * @param {string | null} testPlanId
      * @param {string} branch
@@ -230,17 +228,18 @@ class TestPlanRunner {
         Logger.setExecutionId(executionId);
         beforeTests.forEach(test => { test.isBeforeTestPlan = true; });
         afterTests.forEach(test => { test.isAfterTestPlan = true; });
-        const testStatus = new TestRunStatus(_.concat(beforeTests, tests, afterTests), tpOptions, testPlanId, branch);
+        const testStatus = new TestRunStatus([].concat(beforeTests, tests, afterTests), tpOptions, testPlanId, branch);
 
-        const configs = _.chain(_.concat(beforeTests, tests, afterTests))
+        const configs = _.chain([].concat(beforeTests, tests, afterTests))
             .map(test => test.overrideTestConfig?.name || '')
             .uniq()
             .compact()
             .value();
+        /** @type {string | null} */
         const configName = configs?.length === 1 ? configs[0] : null;
 
         const isCodeMode = tpOptions.files.length > 0;
-        const testNames = tpOptions.lightweightMode?.onlyTestIdsNoSuite ? [] : _.concat(beforeTests, tests, afterTests).map(test => test.name);
+        const testNames = tpOptions.lightweightMode?.onlyTestIdsNoSuite ? [] : [].concat(beforeTests, tests, afterTests).map(test => test.name);
 
         const testListInfoPromise = tpOptions.lightweightMode?.onlyTestIdsNoSuite ?
             { beforeTests, tests, afterTests } :
@@ -276,7 +275,7 @@ class TestPlanRunner {
 
     /**
      * @private
-     * @param {Awaited<ReturnType<typeof import('../runOptions')['process']>>} options
+     * @param {import('../runOptions').RunnerOptions} options
      * @param {string} branchToUse
      */
     async runTestPlans(options, branchToUse) {
@@ -347,7 +346,7 @@ class TestPlanRunner {
 
     /**
      * @private
-     * @param {Awaited<ReturnType<typeof import('../runOptions')['process']>>} options
+     * @param {import('../runOptions').RunnerOptions} options
      * @param {string} branchToUse
      */
     async runAnonymousTestPlan(options, branchToUse) {
@@ -379,13 +378,13 @@ class TestPlanRunner {
                 suiteResult.runName = `rerun-${options.rerunFailedByRunId}`;
             }
         }
-        const testPlanName = options.overrideExecutionName || suiteResult.runName || _.concat(options.label, options.name, options.suites).join(' ');
+        const testPlanName = options.overrideExecutionName || suiteResult.runName || [].concat(options.label, options.name, options.suites).join(' ');
         const isAnonymous = true;
         perf.log('Right before validateConfig + runAnonymousTestPlan tests map');
         return await utils.promiseMap(suiteResult.tests, async suiteTests => { // array of results per execution
             //override result id for remote run mode and run only the first test data
             if (options.resultId) {
-                const firstTest = _.first(suiteTests);
+                const firstTest = suiteTests[0];
                 firstTest.resultId = options.resultId;
                 suiteTests = [firstTest];
             }
@@ -400,7 +399,7 @@ class TestPlanRunner {
     }
 
     /**
-     * @param {Awaited<ReturnType<typeof import('../runOptions')['process']>>} options
+     * @param {import('../runOptions').RunnerOptions} options
      */
     async run(options) {
         const branchToUse = branchService.getCurrentBranch();

package/runners/buildCodeTests.js

@@ -122,6 +122,7 @@ async function buildCodeTests(files, webpackConfig = { mode: 'development' }, ru
         throw new ArgError(`Compilation Webpack Error in tests: ${e.message}`);
     }
 
+    /** @type {{ code: string; name: string; }[]} */
     const fileResults = files.map((file, i) => ({ code: mfs.readFileSync(path.resolve('./dist', `${fileHashes[i]}.bundle.js`)), name: file })); // read all files
 
     suite.tests = [fileResults.map(({ code, name }) => ({

package/runners/runnerUtils.js

@@ -7,9 +7,14 @@ const analytics = require('../commons/testimAnalytics');
 const { ArgError } = require('../errors');
 
 
+/**
+ * @param {import('../runOptions').RunnerOptions} options
+ * @param {string} branchToUse
+ * @returns
+ */
 async function getSuite(options, branchToUse) {
     if (options.lightweightMode?.onlyTestIdsNoSuite && options.testId) {
-        return { tests: [options.testId.map(testId => ({ testId, testConfig: { }, resultId: utils.guid() }))] };
+        return { tests: [options.testId.map(testId => ({ testId, testConfig: {}, resultId: utils.guid() }))] };
     }
     // local code test
     if (options.files.length > 0) {
@@ -47,7 +52,11 @@ function calcTestResultStatus(tests) {
 }
 
 
-
+/**
+ * @template T
+ * @param {import('../runOptions').RunnerOptions} options
+ * @param {T[]} testList
+ */
 async function validateConfig(options, testList) {
     const supportedBrowsers = options.mode === 'extension' ? [
         'edge-chromium', 'chrome',

package/services/branchService.js

@@ -1,12 +1,18 @@
-"use strict";
+'use strict';
 
+/** @type {string | undefined} */
 let currentBranch;
 
 function getCurrentBranch() {
-    return currentBranch || "master";
+    return currentBranch || 'master';
 }
-function setCurrentBranch(branchData = "master", acknowledgeAutoDetect = "false") {
-    if (branchData && branchData.branch && branchData.branch === 'master') {
+
+/**
+ * @param {Awaited<ReturnType<import('../commons/initializeUserWithAuth')['initializeUserWithAuth']>>['branchName']} branchData
+ * @param {boolean | string} acknowledgeAutoDetect
+ */
+function setCurrentBranch(branchData = 'master', acknowledgeAutoDetect = 'false') {
+    if (branchData?.branch && branchData.branch === 'master') {
         currentBranch = 'master';
         return;
     }
@@ -19,5 +25,5 @@ function setCurrentBranch(branchData = "master", acknowledgeAutoDetect = "false"
 
 module.exports = {
     getCurrentBranch,
-    setCurrentBranch
+    setCurrentBranch,
 };

package/services/gridService.js

@@ -4,7 +4,7 @@ const _ = require('lodash');
 const Promise = require('bluebird');
 
 const { GridError, ArgError } = require('../errors');
-const { hasTestPlanFlag } = require('../utils');
+const { hasTestPlanFlag, promiseMap } = require('../utils');
 const { gridMessages, gridTypes } = require('../commons/constants');
 const logger = require('../commons/logger').getLogger('grid-service');
 const servicesApi = require('../commons/testimServicesApi');
@@ -37,22 +37,22 @@ function extractHost(hostUrl) {
 
 function getSerializableObject(grid) {
     const host = grid && extractHost(grid.host);
-    const port = grid && grid.port;
-    const path = grid && grid.path;
+    const port = grid?.port;
+    const path = grid?.path;
     const protocol = grid && extractProtocol(grid);
-    const accessToken = grid && grid.token;
-    const slotId = grid && grid.slotId;
-    const tunnel = grid && grid.hybrid && grid.hybrid.tunnel;
-    const user = grid && grid.external && grid.external.user;
-    const key = grid && grid.external && grid.external.key;
-    const type = grid && grid.type;
+    const accessToken = grid?.token;
+    const slotId = grid?.slotId;
+    const tunnel = grid?.hybrid?.tunnel;
+    const user = grid?.external?.user;
+    const key = grid?.external?.key;
+    const type = grid?.type;
     const tunnelUser = type === gridTypes.HYBRID ?
         (tunnel && grid.hybrid.external && grid.hybrid.external[grid.hybrid.tunnel] && grid.hybrid.external[grid.hybrid.tunnel].user) : user;
     const tunnelKey = type === gridTypes.HYBRID ?
         (tunnel && grid.hybrid.external && grid.hybrid.external[grid.hybrid.tunnel] && grid.hybrid.external[grid.hybrid.tunnel].key) : key;
-    const name = grid && grid.name;
+    const name = grid?.name;
     const gridId = grid && (grid._id || grid.gridId);
-    const provider = grid && grid.provider;
+    const provider = grid?.provider;
 
     return {
         host, port, path, protocol, accessToken, slotId, gridId, tunnel, user, key, type, name, provider, tunnelUser, tunnelKey,
@@ -97,14 +97,16 @@ function addItemToGridCache(workerId, companyId, gridId, slotId, browser) {
     gridCache[workerId] = { gridId, companyId, slotId, browser };
 }
 
-function getHostAndPortById(workerId, companyId, projectId, gridId, browser, executionId, options) {
-    return handleGetGridResponse(projectId, companyId, workerId, browser, () => servicesApi.getGridById(companyId, projectId, gridId, browser, executionId));
+function getHostAndPortById(workerId, companyId, projectId, gridId, browser, executionId) {
+    return handleGetGridResponse(projectId, companyId, workerId, browser, () =>
+        servicesApi.getGridById(companyId, projectId, gridId, browser, executionId),
+    );
 }
 
 function getHostAndPortByName(workerId, companyId, projectId, gridName, browser, executionId, options) {
     const get = () => {
-        const grid = options.allGrids && options.allGrids.find(grid => (grid.name || '').toLowerCase() === gridName.toLowerCase());
-        if (grid && grid._id) {
+        const grid = options.allGrids?.find(g => (g.name || '').toLowerCase() === gridName.toLowerCase());
+        if (grid?._id) {
             return servicesApi.getGridById(companyId, projectId, grid._id, browser, executionId);
         }
         return servicesApi.getGridByName(companyId, projectId, gridName, browser, executionId);
@@ -116,26 +118,22 @@ function getAllGrids(companyId) {
     return servicesApi.getAllGrids(companyId);
 }
 
-function getGridDataByGridId(companyId, gridId, allGrids) {
-    return Promise.resolve(allGrids || getAllGrids(companyId))
-        .then(grids => {
-            const grid = grids.find(grid => grid._id === gridId);
-            if (!grid) {
-                throw new ArgError(`Failed to find grid id: ${gridId}`);
-            }
-            return getSerializableObject(grid);
-        });
+async function getGridDataByGridId(companyId, gridId, allGrids) {
+    const grids = await Promise.resolve(allGrids || getAllGrids(companyId));
+    const grid = grids.find(g => g._id === gridId);
+    if (!grid) {
+        throw new ArgError(`Failed to find grid id: ${gridId}`);
+    }
+    return getSerializableObject(grid);
 }
 
-function getGridDataByGridName(companyId, gridName, allGrids) {
-    return Promise.resolve(allGrids || getAllGrids(companyId))
-        .then(grids => {
-            const grid = grids.find(grid => (grid.name || '').toLowerCase() === gridName.toLowerCase());
-            if (!grid) {
-                throw new ArgError(`Failed to find grid name: ${gridName}`);
-            }
-            return getSerializableObject(grid);
-        });
+async function getGridDataByGridName(companyId, gridName, allGrids) {
+    const grids = await Promise.resolve(allGrids || getAllGrids(companyId));
+    const grid = grids.find(g => (g.name || '').toLowerCase() === gridName.toLowerCase());
+    if (!grid) {
+        throw new ArgError(`Failed to find grid name: ${gridName}`);
+    }
+    return getSerializableObject(grid);
 }
 
 function releaseGridSlot(workerId, projectId) {
@@ -184,7 +182,7 @@ function releaseAllSlots(projectId) {
     }
 
     logger.warn('not all slots released before end runner flow', { projectId });
-    return Promise.map(workerIds, workerId => releaseGridSlot(workerId, projectId))
+    return promiseMap(workerIds, workerId => releaseGridSlot(workerId, projectId))
         .catch(err => logger.error('failed to release all slots', { err, projectId }));
 }
 
@@ -266,20 +264,18 @@ async function getGridData(options) {
     throw new GridError('Missing host or grid configuration');
 }
 
-const getGridSlot = Promise.method(_getGridSlot);
-
-async function _getGridSlot(browser, executionId, testResultId, onGridSlot, options, workerId) {
-    const getGridDataFromServer = () => {
+async function getGridSlot(browser, executionId, testResultId, onGridSlot, options, workerId) {
+    const getGridDataFromServer = async () => {
         const { host, project, grid, gridId, useLocalChromeDriver, useChromeLauncher, company = {} } = options;
         const companyId = company.companyId;
         if (useLocalChromeDriver || useChromeLauncher) {
             return { mode: 'local' };
         }
         if (host) {
-            return Promise.resolve(getOptionGrid(options));
+            return getOptionGrid(options);
         }
         if (gridId) {
-            return getHostAndPortById(workerId, companyId, project, gridId, browser, executionId, options);
+            return getHostAndPortById(workerId, companyId, project, gridId, browser, executionId);
         }
         if (grid) {
             return getHostAndPortByName(workerId, companyId, project, grid, browser, executionId, options);

package/services/localRCASaver.js

@@ -37,6 +37,10 @@ function mapFilesToLocalDrive(test, logger) {
     }
 }
 
+/**
+ * @param {Partial<Pick<import('../runOptions').AgentModeOptions, 'agentPort' | 'agentBind'> & Pick<import('../runOptions').RunnerOptions, 'saveRCALocally'>>} param0
+ * @returns {Promise<import('net').AddressInfo>}
+ */
 async function initServer({ agentPort, agentBind, saveRCALocally }) {
     const multer = await lazyRequire('multer');
     saveRCALocally = typeof saveRCALocally === 'string' ? saveRCALocally : DEFUALT_PATH;

package/testRunStatus.js

@@ -17,6 +17,7 @@ const { calculateCoverage } = require('./coverage/jsCoverage');
 const featureAvailabilityService = require('./commons/featureAvailabilityService');
 const featureFlags = require('./commons/featureFlags');
 const { mapFilesToLocalDrive } = require('./services/localRCASaver');
+const { promiseMap } = require('./utils');
 
 const gitBranch = utils.getEnvironmentGitBranch();
 const gitCommit = process.env.GIT_COMMIT || process.env.CIRCLE_SHA1 || process.env.TRAVIS_COMMIT;
@@ -400,7 +401,7 @@ class RunStatus {
 
                 const reportExecutionStarted = () => {
                     const testResults = _.cloneDeep(this.testRunStatus);
-                    return Promise.map(Object.keys(testResults), testResultId => {
+                    return promiseMap(Object.keys(testResults), testResultId => {
                         const test = testResults[testResultId];
                         const testData = test.config?.testData;
                         const testId = test.testId;
@@ -498,10 +499,10 @@ class RunStatus {
             });
     }
 
-    markAllQueuedTests(executionId, status, failureReason, success) {
+    async markAllQueuedTests(executionId, status, failureReason, success) {
         const queuedResultIds = Object.keys(this.testRunStatus).filter(resultId => this.getTestResult(resultId).status === 'QUEUED');
 
-        return servicesApi.updateExecutionTests(
+        await servicesApi.updateExecutionTests(
             executionId,
             ['QUEUED'],
             status,
@@ -510,12 +511,14 @@ class RunStatus {
             this.startTime,
             null,
             this.options.project
-        ).then(() => Promise.each(queuedResultIds, resultId => {
+        );
+        for (const resultId of queuedResultIds) {
             const test = this.getTestResult(resultId);
             test.status = status;
             test.failureReason = failureReason;
             test.success = success;
-        })).then(() => this.testRunStatus);
+        }
+        return this.testRunStatus;
     }
 }
 

package/utils/argsUtils.js

@@ -0,0 +1,86 @@
+// @ts-check
+
+'use strict';
+
+const { sessionType, testStatus: testStatusConst } = require('../commons/constants');
+
+
+/**
+ * @typedef {import('../runOptions').Options} Options
+ * @typedef {import('../runOptions').InitModeOptions} InitModeOptions
+ * @typedef {import('../runOptions').LoginModeOptions} LoginModeOptions
+ * @typedef {import('../runOptions').TunnelOptions} TunnelOptions
+ * @typedef {import('../runOptions').NgrokTunnelOptions} NgrokTunnelOptions
+ * @typedef {import('../runOptions').TunnelDaemonOptions} TunnelDaemonOptions
+ * @typedef {import('../runOptions').RunnerOptions} RunnerOptions
+ */
+
+/** @param {RunnerOptions} options */
+function getSessionType(options) {
+    return options.files.length > 0 ? sessionType.CODEFUL : sessionType.CODELESS;
+}
+
+/**
+ * @param {RunnerOptions} options
+ * @param {{ runConfig: { browserValue: string } }[]} testList
+ */
+function getUniqBrowsers(options, testList) {
+    if ((options.testConfigNames?.length || options.testConfigIds?.length || options.testPlan.length || options.testPlanIds.length) && !options.browser) {
+        return [...new Set(testList.map(t => t.runConfig.browserValue))];
+    }
+    return [options.browser?.toLowerCase()];
+}
+
+/** @param {RunnerOptions} options */
+const hasTestPlanFlag = (options) => Boolean(options.testPlan?.length || options.testPlanIds?.length);
+
+/** @param {RunnerOptions} options */
+const isRemoteRun = (options) => options.resultId && options.source === 'remote-run';
+
+/**
+ * @param {{ testStatus?: string }} test
+ * @param {RunnerOptions} options
+ */
+const isQuarantineAndNotRemoteRun = (test, options) => test.testStatus === testStatusConst.QUARANTINE && !isRemoteRun(options) && !options.runQuarantinedTests;
+
+function getArgsOnRemoteRunFailure() {
+    const { argv: args } = process;
+    if (!args.includes('--remoteRunId')) {
+        return undefined;
+    }
+    return {
+        remoteRunId: args[args.indexOf('--remoteRunId') + 1],
+        projectId: args[args.indexOf('--project') + 1],
+        token: args[args.indexOf('--token') + 1],
+    };
+}
+
+
+/** @type {(options: Options) => options is InitModeOptions} options */
+// @ts-ignore should be `as any` etc
+const isInitCodimMode = (options) => Boolean(options.initCodimMode);
+
+/** @type {(options: Options) => options is LoginModeOptions} options */
+// @ts-ignore should be `as any` etc
+const isLoginMode = (options) => Boolean(options.loginMode);
+
+/** @type {(options: Options) => options is TunnelOptions} options */
+// @ts-ignore should be `as any` etc
+const isTunnelOnlyMode = (options) => Boolean(options.tunnelOnlyMode);
+
+/** @type {(options: Options) => options is RunnerOptions & { createPrefechedData: true; }} options */
+// @ts-ignore should be `as any` etc
+const isCreatePrefetchedDataMode = (options) => Boolean(options.createPrefechedData);
+
+module.exports = {
+    getSessionType,
+    getUniqBrowsers,
+    hasTestPlanFlag,
+    isRemoteRun,
+    isQuarantineAndNotRemoteRun,
+    getArgsOnRemoteRunFailure,
+    isInitCodimMode,
+    isLoginMode,
+    isTunnelOnlyMode,
+    isCreatePrefetchedDataMode,
+};

package/utils/argsUtils.test.js

@@ -0,0 +1,32 @@
+const chai = require('chai'); // eslint-disable-line import/no-extraneous-dependencies
+const argsUtils = require('./argsUtils');
+
+const expect = chai.expect;
+
+describe('argsUtils', () => {
+    describe('getArgsOnRemoteRunFailure', () => {
+        let originalArgv;
+
+        beforeEach(() => {
+            originalArgv = process.argv;
+        });
+
+        afterEach(() => {
+            process.argv = originalArgv;
+        });
+
+        it('should return undefined if no remote run is current', () => {
+            process.argv = ['node', 'file.js', '--token', 'token', '--project', 'project-id'];
+            expect(argsUtils.getArgsOnRemoteRunFailure()).to.be.undefined;
+        });
+
+        it('should return details if remote run is current', () => {
+            process.argv = ['node', 'file.js', '--token', 'token', '--project', 'project-id', '--remoteRunId', 'remote-run-id'];
+            expect(argsUtils.getArgsOnRemoteRunFailure()).to.eql({
+                remoteRunId: 'remote-run-id',
+                projectId: 'project-id',
+                token: 'token',
+            });
+        });
+    });
+});

package/utils/fsUtils.js

@@ -0,0 +1,154 @@
+// @ts-check
+
+'use strict';
+
+const path = require('path');
+const pRetry = require('p-retry');
+const decompress = require('decompress');
+const stringUtils = require('./stringUtils');
+const httpRequest = require('../commons/httpRequest');
+const { promises: fsPromises, createReadStream, createWriteStream, statSync } = require('fs');
+
+const DOWNLOAD_RETRY = 3;
+
+function getCliLocation() {
+    let cliLocation;
+    if (!require.main) { // we're in a REPL
+        return process.cwd(); // fall back on the current working directory
+    }
+    if (require.main.filename.includes('/src') || require.main.filename.includes('\\src') || process.env.IS_UNIT_TEST) {
+        cliLocation = path.resolve(__dirname, '../../');
+    } else {
+        cliLocation = path.resolve(__dirname, '../');
+    }
+
+    return cliLocation;
+}
+
+/**
+ * @param {string} url
+ */
+const download = async (url) => pRetry(() => httpRequest.download(url), { retries: DOWNLOAD_RETRY });
+
+/**
+ * @param {string} url
+ * @param {import('fs').PathLike} saveToLocation
+ */
+const downloadAndSave = async (url, saveToLocation) => {
+    const res = await download(url);
+    return fsPromises.writeFile(saveToLocation, res.body);
+};
+
+/**
+ * @param {import('fs').PathLike} readFile
+ * @param {import('fs').PathLike} destFile
+ * @return {Promise<void>}
+ */
+const copy = async (readFile, destFile) => new Promise((resolve, reject) => {
+    try {
+        // TODO: can this use fsPromises.copyFile?
+        const file = createWriteStream(destFile);
+        createReadStream(readFile).pipe(file);
+        file.on('finish', () => {
+            file.close(() => resolve());
+        });
+    } catch (err) {
+        reject(err);
+    }
+});
+
+/**
+ * @param {string} location
+ * @param {string=} fileName
+ */
+function getSourcePath(location, fileName) {
+    if (stringUtils.isURL(location)) {
+        return fileName || path.join(process.cwd(), location.replace(/^.*[\\\/]/, ''));
+    }
+
+    return fileName || path.basename(location);
+}
+
+/**
+ * @param {string} location
+ * @param {string} fileName
+ */
+const getSource = async (location, fileName) => {
+    const destFile = getSourcePath(location, fileName);
+    if (stringUtils.isURL(location)) {
+        return downloadAndSave(location, destFile);
+    }
+
+    return copy(location, destFile);
+};
+
+/**
+ * @param {string} location
+ */
+const getSourceAsBuffer = async (location) => {
+    if (stringUtils.isURL(location)) {
+        return download(location);
+    }
+    return fsPromises.readFile(location);
+};
+
+/**
+ * @param {string} srcZipFile
+ * @param {string} destZipPath
+ */
+const unzipFile = async (srcZipFile, destZipPath) => await decompress(srcZipFile, destZipPath);
+
+/**
+ * @param {import('fs').PathLike} fileLocation
+ */
+const getLocalFileSizeInMB = (fileLocation) => {
+    const stats = statSync(fileLocation);
+    const fileSizeInBytes = stats.size;
+    return fileSizeInBytes / 1000000;
+};
+
+
+function getRunnerVersion() {
+    try {
+        /** @type {import('../../package.json')} */
+        const pack = require(`${__dirname}/../package.json`); // eslint-disable-line import/no-dynamic-require
+        return pack.version;
+    } catch (err) {
+        return '';
+    }
+}
+
+function getEnginesVersion() {
+    try {
+        /** @type {import('../../package.json')} */
+        const pack = require(`${__dirname}/../package.json`); // eslint-disable-line import/no-dynamic-require
+        return pack.engines.node;
+    } catch (err) {
+        return '';
+    }
+}
+
+async function getEnginesVersionAsync() {
+    try {
+        /** @type {import('../../package.json')} */
+        const pack = JSON.parse(await fsPromises.readFile(`${__dirname}/../package.json`, 'utf8'));
+        return pack.engines.node;
+    } catch (err) {
+        return '';
+    }
+}
+
+module.exports = {
+    getCliLocation,
+    download,
+    downloadAndSave,
+    copy,
+    getSourcePath,
+    getSource,
+    getSourceAsBuffer,
+    unzipFile,
+    getLocalFileSizeInMB,
+    getRunnerVersion,
+    getEnginesVersion,
+    getEnginesVersionAsync,
+};