@testim/testim-cli 3.288.0 → 3.290.0-beta

package/commons/npmWrapper.test.js

@@ -1,374 +0,0 @@
-'use strict';
-
-const proxyquire = require('proxyquire').noCallThru();
-const { sinon, expect } = require('../../test/utils/testUtils');
-const os = require('os');
-const { NpmPermissionsError } = require('../errors');
-const path = require('path');
-
-const fs = require('fs');
-
-describe('npmWrapper', () => {
-    describe('installPackageLocally', () => {
-        describe('unit', () => {
-            class ExecError extends Error {
-                constructor(stderr) {
-                    super();
-                    this.stderr = stderr;
-                }
-            }
-
-            let npmWrapper;
-
-            let fakeChildProcess;
-            let fakeLogger;
-            let fakeFS;
-            let originalConsole;
-            beforeEach(() => {
-                fakeChildProcess = { exec: sinon.stub() };
-                fakeLogger = { warn: sinon.stub(), info: sinon.stub() };
-                fakeFS = {
-                    promises: {
-                        access: sinon.stub().rejects(new Error()),
-                    },
-                };
-                originalConsole = global.console;
-                global.console = { log: sinon.stub(), error: sinon.stub() };
-
-                npmWrapper = proxyquire('./npmWrapper', {
-                    child_process: fakeChildProcess,
-                    fs: fakeFS,
-                    './logger': { getLogger: () => fakeLogger },
-                });
-            });
-
-            afterEach(() => {
-                global.console = originalConsole;
-            });
-
-            function stubExecRejection(err) {
-                fakeChildProcess.exec.yields(undefined, Promise.reject(err));
-            }
-
-            it('should call npm with expected arguments', async () => {
-                fakeChildProcess.exec.yields(undefined, []); //resolve without errors
-                const cwd = '/some/dir';
-                const pkg = 'some-package';
-                const expectedCmd = 'npm i some-package --no-save --no-prune --prefer-offline --no-audit --progress=false';
-                const expectedExecParams = { cwd };
-
-                await npmWrapper.installPackageLocally(cwd, pkg);
-
-                expect(fakeChildProcess.exec).to.have.been.calledOnce;
-                const [cmd, execParams] = fakeChildProcess.exec.firstCall.args;
-                expect(cmd).to.eql(expectedCmd);
-                expect(execParams).to.eql(expectedExecParams);
-            });
-
-            it('should throw an error if nothing was printed to stderr', async () => {
-                const execErr = new ExecError(undefined);
-
-                stubExecRejection(execErr);
-
-                await expect(npmWrapper.installPackageLocally('/some/dir', 'some-package')).to.be.rejectedWith(execErr);
-            });
-
-            it('should throw an error if an error which isnt related to permissions occurred', async () => {
-                const execErr = new ExecError('not related, really');
-
-                stubExecRejection(execErr);
-
-                await expect(npmWrapper.installPackageLocally('/some/dir', 'some-package')).to.be.rejectedWith(execErr);
-            });
-
-            it('should throw an error if stderr includes "EACCES", but the path was not specified', async () => {
-                const execErr = new ExecError('EACCES permission denied, oh no');
-
-                stubExecRejection(execErr);
-
-                await expect(npmWrapper.installPackageLocally('/some/dir', 'some-package')).to.be.rejectedWith(execErr);
-            });
-
-            [
-                {
-                    stderr: 'EACCES\n\tpermission denied, access \'/some/path\'\n\t',
-                    expectedPath: '/some/path',
-                },
-                {
-                    stderr: `npm WARN @testim/testim-cli@3.108.0 No repository field.
-npm WARN @testim/testim-cli@3.108.0 license should be a valid SPDX license expression
-
-npm ERR! code EACCES
-npm ERR! syscall access
-npm ERR! path /usr/local/lib/node_modules/@testim/testim-cli/node_modules
-npm ERR! errno -13
-npm ERR! Error: EACCES: permission denied, access '/usr/local/lib/node_modules/@testim/testim-cli/node_modules'
-npm ERR!  [Error: EACCES: permission denied, access '/usr/local/lib/node_modules/@testim/testim-cli/node_modules'] {
-npm ERR!   errno: -13,
-npm ERR!   code: 'EACCES',
-npm ERR!   syscall: 'access',
-npm ERR!   path: '/usr/local/lib/node_modules/@testim/testim-cli/node_modules'
-npm ERR! }`,
-                    expectedPath: '/usr/local/lib/node_modules/@testim/testim-cli/node_modules',
-                },
-            ].forEach(({ stderr, expectedPath }) => {
-                it(`should throw an NpmPermissionsError if stderr is ${stderr}`, async () => {
-                    const execErr = new ExecError(stderr);
-
-                    stubExecRejection(execErr);
-
-                    expect(npmWrapper.installPackageLocally('/some/dir', 'some-package')).to.be
-                        .rejectedWith(NpmPermissionsError, `Testim had missing write access to ${expectedPath}`);
-                });
-
-                it(`should print the path to console error if stderr is ${stderr}`, async () => {
-                    const execErr = new ExecError(stderr);
-                    const packageName = 'some-package';
-                    const expectedMessage = `
-
-Testim failed installing the package ${packageName} due to insufficient permissions.
-This is probably due to an installation of @testim/testim-cli with sudo, and running it without sudo.
-Testim had missing write access to ${expectedPath}
-
-`;
-
-                    stubExecRejection(execErr);
-
-                    try {
-                        await npmWrapper.installPackageLocally('/some/dir', packageName);
-                    } catch {
-                        //it doesn't really matter if an error was thrown or not
-                    } finally {
-                        // eslint-disable-next-line no-console
-                        expect(console.error).to.have.been.calledOnceWith(expectedMessage);
-                    }
-                });
-
-                it(`should log the error if stderr is ${stderr}`, async () => {
-                    const execErr = new ExecError(stderr);
-                    const packageName = 'some-package';
-                    const expectedInLog = {
-                        package: packageName,
-                        path: expectedPath,
-                    };
-
-                    stubExecRejection(execErr);
-
-                    try {
-                        await npmWrapper.installPackageLocally('/some/dir', packageName);
-                    } catch {
-                        //it doesn't really matter if an error was thrown or not
-                    } finally {
-                        // eslint-disable-next-line no-console
-                        expect(fakeLogger.info).to.have.been.calledOnce;
-                        const [message, body] = fakeLogger.info.firstCall.args;
-                        expect(message).to.eql('Failed to install package due to insufficient write access');
-                        expect(body).to.include(expectedInLog);
-                    }
-                });
-            });
-        });
-
-        describe('integration', () => {
-            const npmWrapper = require('./npmWrapper');
-
-            it('should install a package on the designated folder', async () => {
-                const dirToInstall = path.resolve(os.tmpdir(), `runnerTest_npmWrapper_${Date.now()}`);
-                const pkg = 'map-obj';
-                fs.mkdirSync(dirToInstall);
-                const expectedFile = path.resolve(dirToInstall, 'node_modules', pkg, 'package.json');
-
-                await npmWrapper.installPackageLocally(dirToInstall, pkg);
-
-                expect(fs.existsSync(expectedFile), 'expected package.json file to be generated').to.be.true;
-                // eslint-disable-next-line import/no-dynamic-require
-                expect(require(expectedFile).name, 'unexpected package was installed').to.be.eql(pkg);
-            }).timeout(20000);
-
-            it('should throw an NpmPermissionsError if npm had permission issues', async () => {
-                const dirToInstall = path.resolve(os.tmpdir(), `runnerTest_npmWrapper_${Date.now()}`);
-                fs.mkdirSync(dirToInstall);
-                const nodeModulesDir = path.resolve(dirToInstall, 'node_modules');
-                fs.mkdirSync(nodeModulesDir);
-                fs.chmodSync(nodeModulesDir, '000'); //no permissions at all
-                const pkg = 'map-obj';
-                const unexpectedDir = path.resolve(nodeModulesDir, pkg);
-
-                await expect(npmWrapper.installPackageLocally(dirToInstall, pkg)).to.be.rejectedWith(NpmPermissionsError);
-
-                expect(fs.existsSync(unexpectedDir), 'expected the package not to be installed - this could be a problem with the test itself, and not the tested class').to.be.false;
-            }).timeout(20000);
-        });
-
-        describe('shirnkwrap handling', () => {
-            let fakeChildProcess;
-            let fakeLogger;
-            let originalConsole;
-            const shrinkwrapPath = '/some/dir/npm-shrinkwrap.json';
-            const shrinkwrapDummyPath = '/some/dir/npm-shrinkwrap-dummy.json';
-            beforeEach(() => {
-                fakeChildProcess = { exec: sinon.stub() };
-                fakeLogger = { warn: sinon.stub(), info: sinon.stub() };
-                originalConsole = global.console;
-                global.console = { log: sinon.stub(), error: sinon.stub() };
-            });
-
-            afterEach(() => {
-                global.console = originalConsole;
-            });
-
-            it('does not call rename if access fails', async () => {
-                const fakeFS = {
-                    promises: {
-                        access: sinon.stub(),
-                        rename: sinon.stub(),
-                    },
-                };
-                fakeFS.promises.access.rejects();
-                const npmWrapper = proxyquire('./npmWrapper', {
-                    child_process: fakeChildProcess,
-                    fs: fakeFS,
-                    './logger': { getLogger: () => fakeLogger },
-                });
-
-                fakeChildProcess.exec.yields(undefined, []); //resolve without errors
-                const cwd = '/some/dir';
-                const pkg = 'some-package';
-                await npmWrapper.installPackageLocally(cwd, pkg);
-                sinon.assert.calledOnce(fakeFS.promises.access);
-                sinon.assert.notCalled(fakeFS.promises.rename);
-                expect(fakeFS.promises.access.getCall(0).args[0]).to.be.equal(shrinkwrapPath);
-            });
-
-            it('calls rename once if rename fails on the first time', async () => {
-                const fakeFS = {
-                    promises: {
-                        access: sinon.stub().resolves(),
-                        rename: sinon.stub().rejects(),
-                    },
-                };
-
-                const npmWrapper = proxyquire('./npmWrapper', {
-                    child_process: fakeChildProcess,
-                    fs: fakeFS,
-                    './logger': { getLogger: () => fakeLogger },
-                });
-
-                fakeChildProcess.exec.yields(undefined, []); //resolve without errors
-                const cwd = '/some/dir';
-                const pkg = 'some-package';
-                await npmWrapper.installPackageLocally(cwd, pkg);
-                sinon.assert.calledOnce(fakeFS.promises.access);
-                sinon.assert.calledOnce(fakeFS.promises.rename);
-            });
-
-            it('calls rename twice if first is success', async () => {
-                const fakeFS = {
-                    promises: {
-                        access: sinon.stub().resolves(),
-                        rename: sinon.stub().resolves(),
-                    },
-                };
-                const npmWrapper = proxyquire('./npmWrapper', {
-                    child_process: fakeChildProcess,
-                    fs: fakeFS,
-                    './logger': { getLogger: () => fakeLogger },
-                });
-
-                fakeChildProcess.exec.yields(undefined, []); //resolve without errors
-                const cwd = '/some/dir';
-                const pkg = 'some-package';
-
-                await npmWrapper.installPackageLocally(cwd, pkg);
-                sinon.assert.calledOnce(fakeFS.promises.access);
-                sinon.assert.calledTwice(fakeFS.promises.rename);
-                expect(fakeFS.promises.access.getCall(0).args[0]).to.be.equal(shrinkwrapPath);
-                expect(fakeFS.promises.rename.getCall(0).args[0]).to.be.equal(shrinkwrapPath);
-                expect(fakeFS.promises.rename.getCall(0).args[1]).to.be.equal(shrinkwrapDummyPath);
-                expect(fakeFS.promises.rename.getCall(1).args[0]).to.be.equal(shrinkwrapDummyPath);
-                expect(fakeFS.promises.rename.getCall(1).args[1]).to.be.equal(shrinkwrapPath);
-            });
-
-            it('doesn\'t throw if first rename fails', async () => {
-                const fakeFS = {
-                    promises: {
-                        access: sinon.stub().resolves(true),
-                        rename: sinon.stub().rejects(),
-                    },
-                };
-                const npmWrapper = proxyquire('./npmWrapper', {
-                    child_process: fakeChildProcess,
-                    fs: fakeFS,
-                    './logger': { getLogger: () => fakeLogger },
-                });
-
-                fakeChildProcess.exec.yields(undefined, []); //resolve without errors
-                const cwd = '/some/dir';
-                const pkg = 'some-package';
-                await npmWrapper.installPackageLocally(cwd, pkg);
-                sinon.assert.calledOnce(fakeFS.promises.access);
-                sinon.assert.calledOnce(fakeFS.promises.rename);
-                expect(fakeFS.promises.access.getCall(0).args[0]).to.be.equal(shrinkwrapPath);
-                expect(fakeFS.promises.rename.getCall(0).args[0]).to.be.equal(shrinkwrapPath);
-                expect(fakeFS.promises.rename.getCall(0).args[1]).to.be.equal(shrinkwrapDummyPath);
-            });
-
-            it('doesn\'t throw is second rename fails', async () => {
-                const fakeFS = {
-                    promises: {
-                        access: sinon.stub().resolves(),
-                        rename: sinon.stub().onFirstCall().resolves().onSecondCall()
-                            .rejects(),
-                    },
-                };
-
-                const npmWrapper = proxyquire('./npmWrapper', {
-                    child_process: fakeChildProcess,
-                    fs: fakeFS,
-                    './logger': { getLogger: () => fakeLogger },
-                });
-
-                fakeChildProcess.exec.yields(undefined, []); //resolve without errors
-                const cwd = '/some/dir';
-                const pkg = 'some-package';
-                await npmWrapper.installPackageLocally(cwd, pkg);
-                sinon.assert.calledOnce(fakeFS.promises.access);
-                sinon.assert.calledTwice(fakeFS.promises.rename);
-                expect(fakeFS.promises.access.getCall(0).args[0]).to.be.equal(shrinkwrapPath);
-                expect(fakeFS.promises.rename.getCall(0).args[0]).to.be.equal(shrinkwrapPath);
-                expect(fakeFS.promises.rename.getCall(0).args[1]).to.be.equal(shrinkwrapDummyPath);
-                expect(fakeFS.promises.rename.getCall(1).args[0]).to.be.equal(shrinkwrapDummyPath);
-                expect(fakeFS.promises.rename.getCall(1).args[1]).to.be.equal(shrinkwrapPath);
-            });
-
-            it('calls rename even if exec fails', async () => {
-                const fakeFS = {
-                    promises: {
-                        access: sinon.stub().resolves(),
-                        rename: sinon.stub().onFirstCall().resolves().onSecondCall()
-                            .rejects(),
-                    },
-                };
-
-                fakeChildProcess.exec.throws();
-
-                const npmWrapper = proxyquire('./npmWrapper', {
-                    child_process: fakeChildProcess,
-                    fs: fakeFS,
-                    './logger': { getLogger: () => fakeLogger },
-                });
-
-                const cwd = '/some/dir';
-                const pkg = 'some-package';
-                await expect(npmWrapper.installPackageLocally(cwd, pkg)).to.be.rejected;
-                sinon.assert.calledOnce(fakeFS.promises.access);
-                sinon.assert.calledTwice(fakeFS.promises.rename);
-                expect(fakeFS.promises.access.getCall(0).args[0]).to.be.equal(shrinkwrapPath);
-                expect(fakeFS.promises.rename.getCall(0).args[0]).to.be.equal(shrinkwrapPath);
-                expect(fakeFS.promises.rename.getCall(0).args[1]).to.be.equal(shrinkwrapDummyPath);
-                expect(fakeFS.promises.rename.getCall(1).args[0]).to.be.equal(shrinkwrapDummyPath);
-                expect(fakeFS.promises.rename.getCall(1).args[1]).to.be.equal(shrinkwrapPath);
-            });
-        });
-    });
-});

package/commons/performance-logger.js

@@ -1,71 +0,0 @@
-/* eslint-disable no-console */
-
-'use strict';
-
-const MEASURE_TESTIM_CLI_PERFORMANCE = process.env.MEASURE_TESTIM_CLI_PERFORMANCE;
-const epoch = Date.now();
-let last = Date.now();
-
-module.exports = {
-    log(...args) {
-        if (!MEASURE_TESTIM_CLI_PERFORMANCE) {
-            return;
-        }
-        const time = Date.now();
-        console.log(`${time - epoch}\t\t\t${time - last}\t\t\t`, ...args);
-        last = time;
-    },
-    measure(fn) {
-        if (!MEASURE_TESTIM_CLI_PERFORMANCE) {
-            return;
-        }
-        const start = Date.now();
-        try {
-            fn();
-        } finally {
-            console.log(fn.name, 'took', Date.now() - start);
-        }
-    },
-    patchPromisePrototype() {
-        // TODO: Stop monkey patching shit
-        // eslint-disable-next-line no-extend-native
-        Promise.prototype.log = function log(message) {
-            if (!MEASURE_TESTIM_CLI_PERFORMANCE) {
-                return this;
-            }
-            return this.then((v) => {
-                module.exports.log(message);
-                return v;
-            });
-        };
-    },
-    measureRequireTimes() {
-        if (!MEASURE_TESTIM_CLI_PERFORMANCE) {
-            return;
-        }
-        const {
-            performance,
-            PerformanceObserver,
-        } = require('perf_hooks');
-        const mod = require('module');
-
-        // Monkey patch the require function
-        mod.Module.prototype.require = performance.timerify(mod.Module.prototype.require);
-        // TODO: Stop monkey patching shit
-        // eslint-disable-next-line no-global-assign
-        require = performance.timerify(require);
-
-        // Activate the observer
-        const obs = new PerformanceObserver((list) => {
-            const entries = list.getEntries();
-            entries.sort((a, b) => b.duration - a.duration).filter(x => x.duration > 1).forEach((entry) => {
-                console.log(`require('${entry[0]}')`, entry.duration);
-            });
-            obs.disconnect();
-        });
-        obs.observe({ entryTypes: ['function'], buffered: true });
-    },
-};
-
-// ew ~ Benji
-module.exports.patchPromisePrototype();

package/commons/preloadTests.js

@@ -1,29 +0,0 @@
-const _ = require('lodash');
-const localRunnerCache = require('./runnerFileCache');
-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 {};
-    }
-    const opts = {
-        branch: options.branch,
-        projectId: options.project,
-    };
-    return await localRunnerCache.memoize(async () => {
-        const results = await promiseMap(options.testId, testId => servicesApi.loadTest({ ...opts, testId }), { concurrency: 2 });
-        return _.keyBy(results, 'testData.id');
-    }, 'loadTests', TEN_HOURS, [opts, options.testId])();
-}
-
-
-module.exports = {
-    preloadTests,
-};

package/commons/prepareRunner.js

@@ -1,85 +0,0 @@
-// @ts-check
-
-const { CLI_MODE } = require('./constants');
-
-const os = require('os');
-const utils = require('../utils');
-const Ajv = require('ajv');
-const prepareRunnerAndTestimStartUtils = require('./prepareRunnerAndTestimStartUtils');
-const mockNetworkRuleFileSchema = require('./mockNetworkRuleFileSchema.json');
-const { initializeUserWithAuth } = require('./initializeUserWithAuth');
-const { downloadAndInstallChromium } = require('../chromiumInstaller');
-
-const MAX_RULE_FILE_SIZE_IN_MB = 1;
-const PREPARE_MOCK_NETWORK_ERROR_PREFIX = 'JSON file supplied to --mock-network-pattern';
-
-const logger = require('./logger').getLogger('prepare runner');
-
-/** @param {import('../runOptions').RunnerOptions} options */
-async function prepare(options) {
-    /**
-     * @type {Promise<void>}
-     */
-    let chromedriverPromise = Promise.resolve();
-
-    const hasNoGrid = !options.host && !options.gridId && !options.grid && (!options.testPlan || options.testPlan.length === 0);
-    const isTdkRun = options.files.length !== 0;
-    if ((hasNoGrid && isTdkRun) || options.useLocalChromeDriver) {
-        options.chromeBinaryLocation = options.downloadBrowser ? await downloadAndInstallChromium() : options.chromeBinaryLocation;
-        chromedriverPromise = prepareRunnerAndTestimStartUtils.prepareChromeDriver(
-            { projectId: options.project, userId: options.user },
-            { chromeBinaryLocation: options.chromeBinaryLocation },
-            Boolean(options.lightweightMode?.general)
-        );
-        options.useLocalChromeDriver = true;
-    }
-
-    if (!options.playerRequirePath && options.mode !== CLI_MODE.EXTENSION) {
-        await prepareRunnerAndTestimStartUtils.preparePlayer(options.playerLocation, options.canary);
-    }
-    if (options.mode === CLI_MODE.EXTENSION && !options.ext) {
-        await prepareRunnerAndTestimStartUtils.prepareExtension(options.extensionLocation);
-    }
-
-    let customExtensionLocation;
-
-    if (options.installCustomExtension) {
-        const unlimitedSize = Boolean(options.useLocalChromeDriver || options.useChromeLauncher);
-        customExtensionLocation = await prepareRunnerAndTestimStartUtils.prepareCustomExtension(options.installCustomExtension, unlimitedSize);
-    }
-
-    await chromedriverPromise;
-
-    return customExtensionLocation;
-}
-
-async function prepareMockNetwork(location) {
-    logger.info('prepare MockNetwork', { 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.toString('utf-8'));
-    } catch (error) {
-        throw new Error(`${PREPARE_MOCK_NETWORK_ERROR_PREFIX} cannot be parsed.${os.EOL}${error}`);
-    }
-
-    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);
-        throw new Error(`${PREPARE_MOCK_NETWORK_ERROR_PREFIX} is malformed.${os.EOL}${errors}`);
-    }
-
-    return rulesJson.entries;
-}
-
-module.exports = {
-    prepare,
-    prepareMockNetwork,
-    initializeUserWithAuth,
-};