@testim/testim-cli 3.289.0 → 3.290.1-beta

package/coverage/SummaryToObjectReport.js

@@ -1,19 +0,0 @@
-'use strict';
-
-const { ReportBase } = require('istanbul-lib-report');
-
-class SummaryToObjectReport extends ReportBase {
-    constructor(opts) {
-        super();
-
-        opts = opts || {};
-        this.appendToObject = opts.appendToObject || {};
-    }
-
-    onStart(node) {
-        const summary = node.getCoverageSummary();
-        this.appendToObject = Object.assign(this.appendToObject, summary.toJSON());
-    }
-}
-
-module.exports = SummaryToObjectReport;

package/coverage/jsCoverage.js

@@ -1,252 +0,0 @@
-'use strict';
-
-const servicesApi = require('../commons/testimServicesApi');
-const fs = require('fs');
-const fsPromises = require('fs/promises');
-const path = require('path');
-const mkdirp = require('mkdirp');
-const lazyRequire = require('../commons/lazyRequire');
-const libReport = require('istanbul-lib-report');
-const reports = require('istanbul-reports');
-const SummaryToObjectReport = require('./SummaryToObjectReport');
-const ora = require('ora');
-const moment = require('moment');
-const TestExclude = require('test-exclude');
-const { ArgError } = require('../errors');
-const { promiseMap } = require('../utils');
-
-const logger = require('../commons/logger').getLogger('test-run-status');
-
-const convertToURL = (path) => {
-    try {
-        return new URL(path);
-    } catch (err) {
-        try {
-            return new URL(`file://${path}`);
-        } catch (e) {
-            return {};
-        }
-    }
-};
-
-const pathHasQueryParam = (path) => {
-    const urlObj = convertToURL(path);
-    return !!urlObj.search;
-};
-
-const parsePath = (path) => {
-    if (!path) {
-        return '';
-    }
-    const urlObj = convertToURL(path);
-    return urlObj.pathname.substring(1);
-};
-
-const excludePath = (codeCoverageInclude, path) => {
-    const pathname = parsePath(path);
-    const exclude = new TestExclude({
-        relativePath: false,
-        include: codeCoverageInclude,
-    });
-
-    return !exclude.shouldInstrument(pathname);
-};
-
-const removeAfterQuestionMark = (str) => str.substring(0, str.indexOf('?'));
-
-module.exports.getSourceMap = async ({ source, sourceMapDir, sourceMapType }) => {
-    const convertSourceMap = await lazyRequire('convert-source-map');
-    if (sourceMapType === 'file' && !sourceMapDir) {
-        throw new ArgError('--code-coverage-source-map-path [path]');
-    }
-    return sourceMapDir ?
-        convertSourceMap.fromMapFileSource(source, sourceMapDir) :
-        convertSourceMap.fromSource(source);
-};
-
-module.exports.remapCoverage = async (options, storagePath, sourceMaps) => {
-    const { codeCoverageInclude } = options;
-    await Promise.all(Object.values(sourceMaps).map(async (sourceMap) => {
-        if (!sourceMap) {
-            return;
-        }
-        const sourceMapObject = sourceMap.toObject();
-        await Promise.all(sourceMapObject.sources.map(async (sourcePath, index) => {
-            if (excludePath(codeCoverageInclude, sourcePath)) {
-                return;
-            }
-            const parsedPath = rewritePath(storagePath, sourcePath);
-            await mkdirp(path.parse(parsedPath).dir);
-            await fsPromises.writeFile(parsedPath, sourceMapObject.sourcesContent[index]);
-        }));
-    }));
-};
-
-const htmlReportLinkMapper = {
-    getPath(node) {
-        if (typeof node === 'string') {
-            return node;
-        }
-        let filePath = node.getQualifiedName();
-        if (node.isSummary()) {
-            if (filePath !== '') {
-                filePath += '/index.html';
-            } else {
-                filePath = 'index.html';
-            }
-        } else {
-            if (pathHasQueryParam(filePath)) {
-                filePath = removeAfterQuestionMark(filePath);
-            }
-            filePath += '.html';
-        }
-        return filePath;
-    },
-
-    relativePath(source, target) {
-        const targetPath = this.getPath(target);
-        const sourcePath = path.dirname(this.getPath(source));
-        return path.posix.relative(sourcePath, targetPath);
-    },
-
-    assetPath(node, name) {
-        return this.relativePath(this.getPath(node), name);
-    },
-};
-
-const rewritePath = (storagePath, fileUrl) => {
-    const parsedPath = path.resolve(storagePath, parsePath(fileUrl));
-    return `${parsedPath}.js`;
-};
-
-module.exports.saveCoverageReports = async (options, coverageMap, reportDir, tempJsDir) => {
-    const { codeCoverageReporter } = options;
-    const reportSummary = {};
-    const context = libReport.createContext({
-        dir: reportDir,
-        coverageMap,
-        watermarks: libReport.getDefaultWatermarks(),
-        sourceFinder: (filePath) => {
-            try {
-                const parsedPath = rewritePath(tempJsDir, filePath);
-                return fs.readFileSync(parsedPath, 'utf8');
-            } catch (ex) {
-                throw new Error(`Unable to lookup source: ${filePath} (${ex.message})`);
-            }
-        },
-    });
-
-    (new SummaryToObjectReport({ appendToObject: reportSummary })).execute(context);
-    if (Array.isArray(codeCoverageReporter)) {
-        codeCoverageReporter.forEach((reporter) => {
-            let cfg = { projectRoot: '/' };
-            if (reporter === 'html') {
-                cfg = { linkMapper: htmlReportLinkMapper };
-            }
-            reports.create(reporter, cfg).execute(context);
-        });
-    }
-    return reportSummary;
-};
-
-module.exports.convertV8ToIstanbul = async (options, { source, sourceMap, functions }) => {
-    const { codeCoverageInclude } = options;
-    if (!sourceMap || sourceMap.sourcemap.sources.length === 0) {
-        return undefined;
-    }
-    const v8toIstanbul = await lazyRequire('v8-to-istanbul');
-    const converter = v8toIstanbul('FAKE_PATH', 0, {
-        source,
-        sourceMap,
-    }, (path) => excludePath(codeCoverageInclude, path));
-    await converter.load();
-    converter.applyCoverage(functions);
-    return converter.toIstanbul();
-};
-
-const collectAndMergeJsCoverageData = async (projectId, branch, runId) => {
-    const DOWNLOAD_COVERAGE_DATA_CONCURRENCY = 20;
-    const { mergeProcessCovs } = await lazyRequire('@bcoe/v8-coverage');
-    let mergedCoverages = { result: [] };
-
-    const covUrlMap = new Map();
-    const realDataRes = await servicesApi.getRealData(projectId, 'testResult', `runId=${runId}`);
-    const testResults = realDataRes.data.docs;
-
-    await promiseMap(
-        testResults.flatMap((testResult) => testResult.JSCoverageURLS || []),
-        async (coverageURL) => {
-            const data = await servicesApi.getS3Artifact(coverageURL, 90000);
-            await promiseMap(data, async (cov) => {
-                if (!covUrlMap.has(cov.url)) {
-                    let text = cov.text;
-                    if (cov.sourceUrl) {
-                        // set temp value to reduce read S3 file
-                        covUrlMap.set(cov.url, 'TEMP');
-                        text = await servicesApi.getS3ArtifactText(cov.sourceUrl);
-                    }
-                    covUrlMap.set(cov.url, {
-                        text,
-                        url: cov.url,
-                        sourceMapType: cov.sourceMapType,
-                        hash: cov.hash,
-                    });
-                }
-                delete cov.text;
-                mergedCoverages = mergeProcessCovs([mergedCoverages, { result: [cov] }]);
-            });
-        },
-        { concurrency: DOWNLOAD_COVERAGE_DATA_CONCURRENCY }
-    );
-
-    return { covUrlMap, mergedCoverages };
-};
-
-module.exports.calculateCoverage = async (options, branchToUse, numOfTests, runId) => {
-    if (!options.collectCodeCoverage) {
-        return undefined;
-    }
-    logger.info('start js coverage process');
-    const spinner = ora(`analyzing coverage for ${numOfTests} ${numOfTests === 1 ? 'test' : 'tests'}`).start();
-    const baseDir = path.resolve(options.codeCoverageReportPath || './coverage');
-    const tempJsDir = path.resolve(baseDir, `.js/${moment().format('DDMMYYYYHHmmss')}`);
-    const sourceMapDir = options.codeCoverageSourceMapPath ? path.resolve(options.codeCoverageSourceMapPath) : undefined;
-    try {
-        const [libCoverage, { mergedCoverages, covUrlMap }] = await Promise.all([
-            lazyRequire('istanbul-lib-coverage'),
-            collectAndMergeJsCoverageData(options.project, branchToUse, runId),
-        ]);
-
-        if (mergedCoverages.result.length === 0) {
-            spinner.fail('Failed to report coverage information - js code coverage is empty');
-            return undefined;
-        }
-        logger.info('start js coverage merge and remap', { numOfFiles: covUrlMap.size, numMergedCoverages: mergedCoverages.result.length });
-        const coverageMap = libCoverage.createCoverageMap({});
-
-        const sourceMaps = {};
-        await Promise.all(mergedCoverages.result.map(async ({ url, functions }) => {
-            const { text: source, sourceMapType } = covUrlMap.get(url);
-
-            const sourceMap = await this.getSourceMap({ sourceMapType, url, source, sourceMapDir });
-            sourceMaps[url] = sourceMap;
-
-            const istanbulCoverage = await this.convertV8ToIstanbul(options, { source, sourceMap, functions });
-            coverageMap.merge(istanbulCoverage);
-        }));
-        await this.remapCoverage(options, tempJsDir, sourceMaps);
-        const coverageSummary = await this.saveCoverageReports(options, coverageMap, baseDir, tempJsDir);
-        spinner.succeed();
-        return coverageSummary;
-    } catch (err) {
-        const baseMsg = 'Failed to report coverage information';
-        if (err instanceof ArgError) {
-            spinner.fail(`${baseMsg}, missing arg: ${err.message}`);
-        } else {
-            spinner.fail(baseMsg);
-        }
-        logger.error(baseMsg, { err });
-    }
-
-    return undefined;
-};

package/credentialsManager.js

@@ -1,142 +0,0 @@
-'use strict';
-
-const fse = require('fs-extra');
-const path = require('path');
-const YAML = require('yaml');
-const os = require('os');
-const utils = require('./utils');
-const { launchChrome } = require('./commons/chrome-launcher');
-
-async function getProjectId() {
-    return getCredentialProperty('projectId');
-}
-
-async function getToken() {
-    return getCredentialProperty('token');
-}
-
-function timeout(promise, ms) {
-    // we need this to time out even if we disabled timeouts system wide
-    return Promise.race([promise, utils.delay(ms).then(() => { throw new utils.TimeoutError('timeout'); })]);
-}
-
-async function getCredentialsFromChrome() {
-    const app = require('express')();
-    const loginInfoFromChrome = (async function waitForChromeToSendData() {
-        return timeout(new Promise(resolve => {
-            app.get('/loginInfo', (req, res) => {
-                resolve(JSON.parse(Buffer.from(req.query.info, 'base64').toString()));
-                res.status(200).end();
-            });
-        }), 60000).catch(() => null);
-    }());
-    await new Promise((resolve, reject) => {
-        const server = app.listen(42543, (err) => {
-            if (err) {
-                reject(err);
-            }
-            resolve(server.address().port);
-        });
-    });
-
-    const { getEditorUrl } = require('./commons/testimServicesApi');
-
-    try {
-        const url = await getEditorUrl();
-        launchChrome(`${url}/#/new-test`);
-    } catch (err) {
-        // eslint-disable-next-line no-console
-        console.log('Unable to open Testim automatically - please manually go to https://app.testim.io');
-    }
-
-    const data = await loginInfoFromChrome;
-    return data;
-}
-
-async function doLogin({ overwriteExisting = true, projects = null } = {}) {
-    const homedir = os.homedir();
-
-    const testimCredentialsFile = path.join(homedir, '.testim');
-
-    const isExist = await fse.pathExists(testimCredentialsFile);
-
-    if (isExist && !overwriteExisting) {
-        return;
-    }
-
-    const credentials = {};
-
-    const prompts = require('prompts');
-    const ora = require('ora');
-
-    const spinner = ora('Getting credentials from Testim extension ...').start();
-
-    if (!projects) {
-        projects = await timeout(Promise.resolve(getCredentialsFromChrome()), 62000).catch(() => null);
-    }
-
-    if (projects?.token) { // V1(legacy) of the login extension API
-        credentials.token = projects.token;
-        credentials.projectId = projects.projectId;
-        spinner.succeed();
-
-        await writeCredentials(testimCredentialsFile, credentials);
-        return;
-    } if (projects?.length) { // V2(current) of the login extension API
-        spinner.succeed();
-
-        const response = projects.length === 1 ?
-            { project: projects[0] } :
-            await prompts({
-                type: 'select',
-                name: 'project',
-                message: 'There are multiple projects associated with your user account. Please select the project you would like to connect to:',
-                choices: projects.map(p => ({ title: p.name, value: p })),
-            }
-            );
-
-        credentials.token = response.project.ci.token;
-        credentials.projectId = response.project.id;
-        await writeCredentials(testimCredentialsFile, credentials);
-        return;
-    }
-
-    spinner.fail();
-    // eslint-disable-next-line no-console
-    console.log('Error getting credentials - please pass `--token` and `--project` to the CLI or try again');
-}
-
-async function writeCredentials(testimCredentialsFile, credentials) {
-    await fse.writeFile(testimCredentialsFile, YAML.stringify(credentials));
-    // eslint-disable-next-line no-console
-    console.log(`Testim credentials saved in '${testimCredentialsFile}'`);
-}
-
-async function getCredentialProperty(property) {
-    const homedir = os.homedir();
-
-    const testimCredentialsFile = path.join(homedir, '.testim');
-
-    const isExist = await fse.pathExists(testimCredentialsFile);
-
-    let credentials = {};
-
-    if (isExist) {
-        try {
-            credentials = YAML.parse((await fse.readFile(testimCredentialsFile)).toString());
-        } catch (err) {
-            // just use new credentials.
-        }
-    }
-
-    // YAML.parse can return `null` or `undefined` if we fail with an empty/malformed file.
-    credentials = credentials || {};
-
-    return credentials[property];
-}
-
-module.exports = {
-    getProjectId,
-    getToken,
-    doLogin,
-};

package/errors.js

@@ -1,161 +0,0 @@
-const { AbortError } = require('p-retry');
-/**
- * NoArgsError - throws when arguments not passed to cli
- *
- */
-function NoArgsError() {
-    this.name = 'NoArgsError';
-    Error.captureStackTrace(this, NoArgsError);
-}
-
-NoArgsError.prototype = Object.create(Error.prototype);
-NoArgsError.prototype.constructor = NoArgsError;
-
-/**
- * ArgError - throws when argument is invalid
- *
- */
-function ArgError(message) {
-    this.message = message;
-    this.name = 'ArgError';
-    Error.captureStackTrace(this, ArgError);
-}
-
-ArgError.prototype = Object.create(Error.prototype);
-ArgError.prototype.constructor = ArgError;
-
-/**
- * SeleniumError - throws when selenium return error
- *
- */
-function SeleniumError(seleniumStack) {
-    this.message = seleniumStack.orgStatusMessage || seleniumStack.message;
-    this.errorType = seleniumStack.type;
-    this.name = 'SeleniumError';
-    Error.captureStackTrace(this, SeleniumError);
-}
-
-SeleniumError.prototype = Object.create(Error.prototype);
-SeleniumError.prototype.constructor = SeleniumError;
-
-/**
- * StopRunOnError
- *
- */
-function StopRunOnError(message) {
-    this.message = message;
-    this.name = 'StopRunOnError';
-    Error.captureStackTrace(this, StopRunOnError);
-}
-
-StopRunOnError.prototype = Object.create(Error.prototype);
-StopRunOnError.prototype.constructor = StopRunOnError;
-
-class GetBrowserError extends Error {
-    constructor(message, type) {
-        super(message);
-        this.type = type;
-    }
-}
-
-class PageNotAvailableError extends AbortError {}
-
-class TimeoutError extends Error {}
-
-class QuotaDepletedError extends Error {}
-
-class GridError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'GridError';
-    }
-
-    toString() {
-        return this.message;
-    }
-}
-
-class GridConcurrencyError extends GridError {
-    constructor(message) {
-        super(message);
-        this.name = 'GridConcurrencyError';
-    }
-}
-
-/**
- * NpmPackageError
- *
- */
-function NpmPackageError(message) {
-    this.message = message;
-    this.name = 'NpmPackageError';
-    Error.captureStackTrace(this, NpmPackageError);
-}
-
-NpmPackageError.prototype = Object.create(Error.prototype);
-NpmPackageError.prototype.constructor = NpmPackageError;
-
-/**
- * SeleniumCrashError
- *
- */
-function SeleniumCrashError() {
-    this.message = 'selenium driver crashed';
-    this.name = 'SeleniumCrashError';
-    Error.captureStackTrace(this, SeleniumCrashError);
-}
-SeleniumCrashError.prototype = Object.create(Error.prototype);
-SeleniumCrashError.prototype.constructor = SeleniumCrashError;
-
-/**
- * IeError
- *
- */
-function IeError(msg = '') {
-    this.message = msg;
-    this.name = 'IeError';
-    Error.captureStackTrace(this, IeError);
-}
-IeError.prototype = Object.create(Error.prototype);
-IeError.prototype.constructor = IeError;
-
-class ClientError extends Error {}
-
-class PlaygroundCodeError extends Error {}
-
-class NpmPermissionsError extends Error {
-    constructor(path) {
-        super(`Testim had missing write access to ${path}`);
-        this.path = path;
-    }
-}
-
-class NotImplementedError extends Error {
-    constructor(descendant = false) {
-        let message = 'not implemented';
-        if (descendant) {
-            message = 'should be implemented on descendant';
-        }
-        super(message);
-    }
-}
-
-module.exports = {
-    NoArgsError,
-    SeleniumError,
-    ArgError,
-    StopRunOnError,
-    GetBrowserError,
-    PageNotAvailableError,
-    GridError,
-    GridConcurrencyError,
-    QuotaDepletedError,
-    NpmPackageError,
-    NpmPermissionsError,
-    SeleniumCrashError,
-    IeError,
-    ClientError,
-    PlaygroundCodeError,
-    NotImplementedError,
-    TimeoutError,
-};

package/executionQueue.js

@@ -1,37 +0,0 @@
-'use strict';
-
-const TestRun = require('./testRunHandler');
-
-class ExecutionQueue {
-    /**
-     * @param {string} executionId
-     * @param {string} executionName
-     * @param {any[]} testList
-     * @param {import('./runOptions').RunnerOptions} options
-     * @param {string} branchToUse
-     * @param {import('./testRunStatus')} testRunStatus
-     */
-    constructor(executionId, executionName, testList, options, branchToUse, testStatus) {
-        this._waitingTests = testList.map(testInfo => new TestRun(executionId, executionName, testInfo, options, branchToUse, testStatus));
-    }
-
-    stop() {
-        this._waitingTests = [];
-    }
-
-    getNext() {
-        const nextTestRunHandler = this._waitingTests.shift();
-        if (nextTestRunHandler) {
-            return nextTestRunHandler;
-        }
-        return undefined;
-    }
-
-    hasMoreTests() {
-        return Boolean(this._waitingTests.length);
-    }
-}
-
-
-
-module.exports = ExecutionQueue;

package/fixLocalBuild.js

@@ -1,24 +0,0 @@
-/* eslint-disable no-console */
-
-'use strict';
-
-// fixes the local build if running the runner locally
-const path = require('path');
-const { execSync } = require('child_process');
-const { existsSync } = require('fs');
-
-const location = path.resolve(__filename);
-const isDevBuild = !location.includes('node_modules') && path.dirname(location).endsWith('src');
-
-if (!isDevBuild) {
-    return;
-}
-
-const isDepBuilt = existsSync(path.resolve(location, '..', '..', '..', 'webdriverio', 'build', 'index.js'));
-
-if (!isDepBuilt) {
-    console.log("Hi developer, we're initializing the runner dev env for the first time for you ❤️");
-    execSync('yarn workspace @testim/webdriverio build', {
-        cwd: path.resolve(location, '..', '..'),
-    });
-}