@testim/testim-cli 3.289.0 → 3.290.0

package/commons/prepareRunner.test.js

@@ -1,144 +0,0 @@
-const { sinon, expect } = require('../../test/utils/testUtils');
-const utils = require('../utils');
-const { prepareMockNetwork } = require('./prepareRunner');
-
-describe('prepareRunner', () => {
-    describe('prepareMockNetwork', () => {
-        const localFileUrl = './rules.json';
-        const remoteFileUrl = 'https://s3/testim/files/rules.json';
-        let getSourceAsBufferStub;
-
-        beforeEach(() => {
-            getSourceAsBufferStub = sinon.stub(utils, 'getSourceAsBuffer');
-        });
-
-        afterEach(() => {
-            sinon.restore();
-        });
-
-        it('prepareMockNetwork rejected with - exceeded 1MB', () => {
-            // Arrange:
-            const buf = Buffer.alloc(1000001);
-            getSourceAsBufferStub.withArgs(localFileUrl).returns(Promise.resolve(buf));
-
-            // Act:
-            const mockNetworkRules = prepareMockNetwork(localFileUrl);
-
-            // Assert:
-            sinon.assert.calledOnce(getSourceAsBufferStub);
-            return expect(mockNetworkRules).to.be.rejectedWith('exceeded 1MB');
-        });
-
-        it('prepareMockNetwork rejected with - cannot be parsed', () => {
-            // Arrange:
-            const buf = Buffer.from('{a: 1}');
-            getSourceAsBufferStub.withArgs(localFileUrl).returns(Promise.resolve(buf));
-
-            // Act:
-            const mockNetworkRules = prepareMockNetwork(localFileUrl);
-
-            // Assert:
-            sinon.assert.calledOnce(getSourceAsBufferStub);
-            return expect(mockNetworkRules).to.be.rejectedWith('cannot be parsed');
-        });
-
-        it('prepareMockNetwork rejected with - is malformed', () => {
-            // Arrange:
-            const buf1 = Buffer.from('{"a": 1}');
-            const buf2 = Buffer.from(JSON.stringify({
-                version: '2.0.0',
-                entries: [],
-            }));
-            const buf3 = Buffer.from(Buffer.from(JSON.stringify({
-                version: '1.0.0',
-                entries: [{
-                    request: {
-                        url: '/test/*',
-                    },
-                }],
-            })));
-            const buf4 = Buffer.from(Buffer.from(JSON.stringify({
-                version: '1.0.0',
-                entries: [{
-                    request: {
-                        url: '/test/*',
-                        method: 'POSTTTTT',
-                    },
-                    response: {
-                        status: 200,
-                    },
-                }],
-            })));
-            const buf5 = Buffer.from(Buffer.from(JSON.stringify({
-                version: '1.0.0',
-                entries: [{
-                    request: {
-                        url: '/test/*',
-                    },
-                    response: {
-                        status: 600,
-                    },
-                }],
-            })));
-            const buf6 = Buffer.from(Buffer.from(JSON.stringify({
-                version: '1.0.0',
-                entries: [{
-                    request: {
-                        url: '/test/*',
-                    },
-                    response: {
-                        status: 400.1,
-                    },
-                }],
-            })));
-            getSourceAsBufferStub.withArgs(`${remoteFileUrl}.1`).returns(Promise.resolve(buf1));
-            getSourceAsBufferStub.withArgs(`${remoteFileUrl}.2`).returns(Promise.resolve(buf2));
-            getSourceAsBufferStub.withArgs(`${remoteFileUrl}.3`).returns(Promise.resolve(buf3));
-            getSourceAsBufferStub.withArgs(`${remoteFileUrl}.4`).returns(Promise.resolve(buf4));
-            getSourceAsBufferStub.withArgs(`${remoteFileUrl}.5`).returns(Promise.resolve(buf5));
-            getSourceAsBufferStub.withArgs(`${remoteFileUrl}.6`).returns(Promise.resolve(buf6));
-
-            // Act:
-            const mockNetworkRules1 = prepareMockNetwork(`${remoteFileUrl}.1`);
-            const mockNetworkRules2 = prepareMockNetwork(`${remoteFileUrl}.2`);
-            const mockNetworkRules3 = prepareMockNetwork(`${remoteFileUrl}.3`);
-            const mockNetworkRules4 = prepareMockNetwork(`${remoteFileUrl}.4`);
-            const mockNetworkRules5 = prepareMockNetwork(`${remoteFileUrl}.5`);
-            const mockNetworkRules6 = prepareMockNetwork(`${remoteFileUrl}.6`);
-
-            // Assert:
-            return Promise.all([
-                expect(mockNetworkRules1).to.be.rejectedWith('is malformed'),
-                expect(mockNetworkRules2).to.be.rejectedWith('is malformed'),
-                expect(mockNetworkRules3).to.be.rejectedWith('is malformed'),
-                expect(mockNetworkRules4).to.be.rejectedWith('is malformed'),
-                expect(mockNetworkRules5).to.be.rejectedWith('is malformed'),
-                expect(mockNetworkRules6).to.be.rejectedWith('is malformed'),
-            ]);
-        });
-
-        it('prepareMockNetwork is fine', () => {
-            // Arrange:
-            const buf = Buffer.from(JSON.stringify({
-                version: '1.2',
-                entries: [{
-                    request: {
-                        url: '/test/*',
-                        method: 'POST',
-                    },
-                    response: {
-                        status: 400,
-                    },
-                }],
-            }));
-            getSourceAsBufferStub.withArgs(localFileUrl).returns(Promise.resolve(buf));
-
-            // Act:
-            const mockNetworkRules = prepareMockNetwork(localFileUrl);
-
-            // Assert:
-            sinon.assert.calledOnce(getSourceAsBufferStub);
-            return expect(mockNetworkRules).to.be.fulfilled;
-        });
-    });
-});

package/commons/prepareRunnerAndTestimStartUtils.js

@@ -1,198 +0,0 @@
-// @ts-check
-
-const path = require('path');
-const fs = require('fs');
-const ms = require('ms');
-const { serializeError } = require('serialize-error');
-const { additionalLogDetails } = require('./logUtils');
-
-const config = require('./config');
-const { ArgError, NpmPermissionsError } = require('../errors');
-const {
-    getCliLocation,
-    isURL,
-    downloadAndSave,
-    getSource,
-    getLocalFileSizeInMB,
-    download,
-    unzipFile,
-    getSourcePath,
-    promiseMap,
-} = require('../utils');
-const localRunnerCache = require('./runnerFileCache');
-const logger = require('./logger').getLogger('prepare runner and testim start');
-
-const MSEC_IN_HALF_DAY = ms('0.5 day');
-const MAX_CUSTOM_EXT_SIZE_MB = 16;
-const MAX_CUSTOM_SIZE_ERROR_MSG = `The size of the custom extension is more than ${MAX_CUSTOM_EXT_SIZE_MB}MB`;
-
-module.exports = {
-    prepareChromeDriver,
-    prepareCustomExtension,
-    prepareExtension,
-    getSessionPlayerFolder,
-    preparePlayer,
-};
-
-/**
- * @param {string} location
- */
-async function prepareCustomExtension(location, unlimitedSize = false) {
-    if (!location) {
-        return undefined;
-    }
-
-    if (isURL(location)) {
-        const destFile = path.join(process.cwd(), location.replace(/^.*[\\\/]/, ''));
-        const contentLength = await getRemoteFileSizeInMB(location);
-        if (contentLength > MAX_CUSTOM_EXT_SIZE_MB && !unlimitedSize) {
-            throw new ArgError(MAX_CUSTOM_SIZE_ERROR_MSG);
-        }
-        await downloadAndSave(location, destFile);
-        return destFile;
-    }
-
-    const destFile = path.resolve(location);
-    if (!fs.existsSync(destFile)) {
-        throw new ArgError(`Failed to find custom extension in location: ${destFile}`);
-    }
-    const fileSize = getLocalFileSizeInMB(destFile);
-    if (fileSize > MAX_CUSTOM_EXT_SIZE_MB && !unlimitedSize) {
-        throw new ArgError(MAX_CUSTOM_SIZE_ERROR_MSG);
-    }
-    return destFile;
-}
-
-
-/**
- * @param {string} url
- */
-async function getRemoteFileSizeInMB(url) {
-    const httpRequest = require('./httpRequest');
-    try {
-        const res = await httpRequest.head(url);
-        const contentLengthHeader = res.headers['content-length'];
-        const contentLengthBytes = contentLengthHeader ? parseInt(contentLengthHeader, 10) : 0;
-        return contentLengthBytes / 1000000;
-    } catch (err) {
-        logger.warn('failed to download custom extension', { err });
-        throw new ArgError(`Failed to download custom extension from location: ${url}`);
-    }
-}
-
-/**
- * @param {string[]} locations
- */
-function prepareExtension(locations) {
-    logger.info('prepare extension', { locations });
-
-    const fullLocations = locations.map(location => ({ location, path: getSourcePath(location) }));
-    return localRunnerCache.memoize(
-        () => promiseMap(fullLocations, ({ location, path }) => getSource(location, path)),
-        'prepareExtension',
-        MSEC_IN_HALF_DAY,
-        fullLocations
-    )();
-}
-
-async function prepareChromeDriver(userDetails = {}, driverOptions = {}, skipIsReadyCheck = false) {
-    const ora = require('ora');
-    const spinner = ora('Starting Driver').start();
-    const chromedriverWrapper = require('./chromedriverWrapper');
-
-    try {
-        await chromedriverWrapper.install();
-        await chromedriverWrapper.start();
-        if (!skipIsReadyCheck) {
-            // @ts-ignore
-            await chromedriverWrapper.isReady(driverOptions);
-        }
-        spinner.succeed('Chrome Driver initiated successfully');
-    } catch (error) {
-        const errorMsg = 'Failed to initiate Chrome Driver';
-
-        if (!(error instanceof NpmPermissionsError)) { //NpmPermissionsError was printed and logged already
-            logger.error(errorMsg, {
-                ...userDetails,
-                ...additionalLogDetails(),
-                error: serializeError(error),
-            });
-            // eslint-disable-next-line no-console
-            console.log(`
-1. If you don't have Chrome, please install it from https://www.google.com/chrome.
-2. If Chrome is installed, please verify it's binary directory:
-    - installed where chromedriver expects it (see https://github.com/SeleniumHQ/selenium/wiki/ChromeDriver#requirements).
-    - exists in your PATH environment variables.
-3. Try adding --chrome-binary-location flag to Testim CLI specifying the exact location of chrome binary in your computer (e.g on Windows "C:/Program Files/Google/Chrome/Application/chrome.exe").
-4. You can always use a standalone Selenium grid and providing it's details with the --host and --port flags (see https://www.npmjs.com/package/selenium-standalone)`);
-        }
-
-        spinner.fail(errorMsg);
-        throw error;
-    }
-}
-
-async function getPlayerVersion() {
-    const url = `${config.BLOB_URL}/extension/sessionPlayer_LATEST_RELEASE`;
-    const res = await download(url);
-    return res.body.toString('utf8');
-}
-
-/**
- * @param {string} location
- * @param {boolean=} canary
- */
-async function getPlayerLocation(location, canary) {
-    if (!isURL(location) || (isURL(location) && canary) || config.IS_ON_PREM) {
-        return location;
-    }
-
-    const ver = await getPlayerVersion();
-    return `${location}-${ver}`;
-}
-
-function getSessionPlayerFolder() {
-    const cliLocation = getCliLocation();
-
-    return path.resolve(cliLocation, 'testim-bin');
-}
-
-function getPlayerDestination() {
-    const testimAppData = getSessionPlayerFolder();
-
-    const playerDestination = path.resolve(testimAppData, 'sessionPlayer.zip');
-
-    return playerDestination;
-}
-
-async function downloadAndUnzip(loc, playerFileName, isRetry = false) {
-    try {
-        await getSource(loc, playerFileName);
-        return await unzipFile(playerFileName, getSessionPlayerFolder());
-    } catch (err) {
-        if (isRetry) {
-            throw err;
-        }
-        return await downloadAndUnzip(loc, playerFileName, true);
-    }
-}
-
-/**
- * @param {string} location
- * @param {boolean=} canary
- */
-async function preparePlayer(location, canary) {
-    logger.info('prepare player', { location, canary });
-    const playerFileName = getPlayerDestination();
-    return localRunnerCache.memoize(
-        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/prepareRunnerAndTestimStartUtils.test.js

@@ -1,73 +0,0 @@
-/* eslint-disable no-console */
-
-'use strict';
-
-const { sinon, expect } = require('../../test/utils/testUtils');
-const proxyquire = require('proxyquire').noCallThru();
-const { NpmPermissionsError } = require('../errors');
-
-describe('prepareRunnerAndTestimStartUtils', () => {
-    describe('prepareChromeDriver', () => {
-        let prepareChromeDriver;
-        let chromeDriverWrapper;
-
-        beforeEach(() => {
-            chromeDriverWrapper = {
-                install: sinon.stub(),
-                start: sinon.stub(),
-                isReady: sinon.stub(),
-            };
-            prepareChromeDriver = proxyquire('./prepareRunnerAndTestimStartUtils', {
-                './chromedriverWrapper': chromeDriverWrapper,
-            }).prepareChromeDriver;
-        });
-
-        afterEach(() => {
-            sinon.restore();
-        });
-
-        it('should call install and start chromedriver', async () => {
-            chromeDriverWrapper.install.resolves();
-            chromeDriverWrapper.start.resolves();
-            chromeDriverWrapper.isReady.resolves();
-            const driverOptions = { someOption: 'option' };
-
-            await prepareChromeDriver({ name: 'some username' }, driverOptions);
-
-            expect(chromeDriverWrapper.install).to.have.been.calledOnce;
-            expect(chromeDriverWrapper.start).to.have.been.calledOnce;
-            expect(chromeDriverWrapper.isReady).to.have.been.calledOnceWithExactly(driverOptions);
-        });
-
-        it('should throw if an NpmPermissionsError was thrown while installing', async () => {
-            const error = new NpmPermissionsError('/path/with/no/access');
-            chromeDriverWrapper.install.rejects(error);
-
-            expect(prepareChromeDriver()).to.be.rejectedWith(error);
-        });
-
-        it('should throw if an Error was thrown while starting', async () => {
-            const error = new Error('oh noes');
-            chromeDriverWrapper.install.resolves();
-            chromeDriverWrapper.start.rejects(error);
-
-            expect(prepareChromeDriver()).to.be.rejectedWith(error);
-        });
-
-        it('should print instructions if Error was thrown while starting', async () => {
-            sinon.stub(console, 'log');
-            const error = new Error('oh noes');
-            chromeDriverWrapper.install.resolves();
-            chromeDriverWrapper.start.rejects(error);
-
-            await expect(prepareChromeDriver()).to.be.rejected;
-            expect(console.log).to.have.been.calledOnceWith(`
-1. If you don't have Chrome, please install it from https://www.google.com/chrome.
-2. If Chrome is installed, please verify it's binary directory:
-    - installed where chromedriver expects it (see https://github.com/SeleniumHQ/selenium/wiki/ChromeDriver#requirements).
-    - exists in your PATH environment variables.
-3. Try adding --chrome-binary-location flag to Testim CLI specifying the exact location of chrome binary in your computer (e.g on Windows "C:/Program Files/Google/Chrome/Application/chrome.exe").
-4. You can always use a standalone Selenium grid and providing it's details with the --host and --port flags (see https://www.npmjs.com/package/selenium-standalone)`);
-        });
-    });
-});

package/commons/requireWithFallback.js

@@ -1,25 +0,0 @@
-/* eslint-disable import/no-dynamic-require */
-
-'use strict';
-
-const path = require('path');
-
-module.exports = {
-    requireWithFallback,
-};
-
-/**
- * Require with statCache issue workaround
- * @param {string} packageNama
- */
-function requireWithFallback(packageNama) {
-    // Workaround for
-    // https://github.com/nodejs/node/issues/31803 statCache
-    const mainPath = path.resolve(
-        path.dirname(require.resolve(`${packageNama}/package.json`)),
-        // @ts-ignore
-        require(`${packageNama}/package.json`).main || ''
-    );
-
-    return require(mainPath);
-}

package/commons/runnerFileCache.js

@@ -1,204 +0,0 @@
-// @ts-check
-
-'use strict';
-
-const path = require('path');
-const debounce = require('lodash/debounce');
-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');
-
-let encryptKeyResolve;
-let encryptAndSaveResolve;
-let cacheEnabled = true;
-let cacheMissAllowed = true;
-let waitingForSave = false;
-
-let _encryptAndSavePromise = new Promise(resolve => { encryptAndSaveResolve = resolve; });
-const _encryptKeyPromise = new Promise(resolve => { encryptKeyResolve = resolve; });
-
-
-const THREE_HOURS = 1000 * 60 * 60 * 3;
-
-const getCacheFileLocation = () => path.resolve(path.resolve(cacheLocation, 'testim.cache'));
-
-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();
-
-async function doesPathExist(dirPath) {
-    try {
-        await fs.promises.access(dirPath, fs.constants.F_OK);
-        return true;
-    } catch (err) {
-        if (err.code === 'ENOENT') {
-            return false;
-        }
-
-        // no permissions to check
-        throw err;
-    }
-}
-
-const encryptAndSave = debounce(async (object) => {
-    let error;
-    try {
-        const key = await _encryptKeyPromise;
-        const iv = crypto.randomBytes(16);
-        const objStr = JSON.stringify(object);
-        const keyBuffer = Buffer.from(key);
-        const cipher = crypto.createCipheriv('aes-256-cbc', Buffer.concat([keyBuffer, Buffer.alloc(32)], 32), iv);
-        const result = Buffer.concat([iv, cipher.update(objStr), cipher.final()]);
-        const pathExists = await doesPathExist(cacheLocation);
-        if (!pathExists) {
-            await fs.promises.mkdir(cacheLocation, { recursive: true });
-        }
-        await fs.promises.writeFile(getCacheFileLocation(), result);
-    } catch (err) {
-        logger.error('failed saving cache', { err });
-        error = err;
-    }
-    if (error) {
-        encryptAndSaveResolve({ success: false, error });
-    } else {
-        encryptAndSaveResolve({ success: true });
-    }
-}, 200);
-
-function decrypt(key, buffer) {
-    const iv = buffer.slice(0, 16);
-    const encryptedText = buffer.slice(16);
-    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()]));
-}
-/**
- * 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 async () => {
-        if (!cacheEnabled) {
-            return await fn();
-        }
-        const originalFnName = fnName;
-        if (parameters) {
-            fnName += JSON.stringify(parameters);
-        }
-        const cached = await get(fnName);
-        if (cached) {
-            logger.debug('cache hit:', { fnName });
-            return cached;
-        }
-        logger.debug('cache miss:', { fnName });
-        if (!cacheMissAllowed) {
-            throw new Error(`Attempted to rebuild cache for ${originalFnName}. cache miss is not allowed with current run configuration`);
-        }
-        const value = await fn();
-        if (value) {
-            await set(fnName, value, duration);
-        }
-        return value;
-    };
-}
-
-async function get(key) {
-    const obj = await localRunnerCache;
-    const valueExpiry = obj[key];
-    if (!valueExpiry) {
-        return undefined; // not in cache
-    }
-    const { value, expiry } = valueExpiry;
-    if (expiry < Date.now()) {
-        return undefined;
-    }
-    if (!value) {
-        return undefined;
-    }
-    return value;
-}
-
-async function set(key, value, ttl) {
-    if (waitingForSave) {
-        logger.error('calling set after waitForSave is not allowed', { key, ttl });
-        throw new Error('calling set after waitForSave is not allowed');
-    }
-    try {
-        const obj = await localRunnerCache;
-        obj[key] = { value, expiry: Date.now() + ttl };
-        _encryptAndSavePromise = new Promise(resolve => { encryptAndSaveResolve = resolve; });
-        encryptAndSave(obj);
-    } catch (e) {
-        logger.error('failed updating cache');
-    }
-}
-
-async function clear() {
-    const obj = await localRunnerCache;
-    Object.keys(obj).forEach(key => {
-        delete obj[key];
-    });
-}
-
-function setEnabled(enabled) {
-    cacheEnabled = enabled;
-}
-
-
-function enableCacheMiss(enabled) {
-    cacheMissAllowed = enabled;
-}
-
-async function waitForSave() {
-    try {
-        waitingForSave = true;
-        return await _encryptAndSavePromise;
-    } finally {
-        waitingForSave = false;
-    }
-}
-
-function setCacheLocation(location) {
-    cacheLocation = location;
-    localRunnerCache = getLocalRunnerCache();
-}
-
-module.exports.setEncryptKey = encryptKeyResolve;
-module.exports.memoize = memoize;
-module.exports.get = get;
-
-module.exports.set = set;
-module.exports.clear = clear;
-module.exports.disable = setEnabled.bind(this, false);
-module.exports.enable = setEnabled.bind(this, true);
-module.exports.isEnabled = function () { return cacheEnabled; };
-module.exports.disableCacheMiss = enableCacheMiss.bind(this, false);
-module.exports.enableCacheMiss = enableCacheMiss.bind(this, true);
-module.exports.isEnabled = function () { return cacheEnabled; };
-module.exports.setCacheLocation = setCacheLocation;
-module.exports.waitForSave = waitForSave;
-module.exports.getCacheFileLocation = getCacheFileLocation;