@testim/testim-cli 3.289.0 → 3.290.0

package/commons/logger.js

@@ -1,178 +0,0 @@
-'use strict';
-
-const winston = require('winston');
-const os = require('os');
-
-const hostname = os.hostname();
-const runnerVersion = getRunnerVersion();
-const config = require('./config');
-
-const isLocal = 'false';
-
-
-const loggerConfig = {
-    privateKey: 'd0eb01da-f966-1663-63c6-8871225d7c39',
-    applicationName: 'testim',
-    subsystemName: 'runner',
-};
-
-function getRunnerVersion() {
-    try {
-        const pack = require(`${__dirname}/../package.json`);
-        return pack.version;
-    } catch (err) {
-        return '';
-    }
-}
-
-function getStreamsAndWaitForFlushPromise() {
-    const transports = [];
-
-    let waitForFlush = () => Promise.resolve();
-
-    if (!config.IS_ON_PREM) {
-        const { CoralogixTransport } = require('../lib/coralogix-winston.transport');
-
-        CoralogixTransport.configure(loggerConfig);
-        const loggerInstance = new CoralogixTransport({
-            category: 'ROOT',
-        });
-        transports.push(loggerInstance);
-
-        waitForFlush = () => loggerInstance.waitForFlush();
-    }
-
-    if (config.LOGGER_CONSOLE) {
-        transports.push(new winston.transports.Console({
-            format: winston.format.combine(winston.format.colorize(), winston.format.simple()),
-        }));
-    }
-    return [transports, waitForFlush];
-}
-
-const [transports, waitForFlush] = getStreamsAndWaitForFlushPromise();
-const level = config.LOGGER_DEBUG ? 'debug' : 'info';
-const defaultMeta = {};
-if (!isLocal.includes('@echo')) {
-    Object.assign(defaultMeta, devFlags());
-
-} else {
-    Object.assign(defaultMeta, localFlags());
-}
-
-const winstonMainLogger = winston.createLogger({
-    levels: winston.config.syslog.levels,
-    level,
-    transports,
-    defaultMeta: { name: 'runner', hostname, nodeVersion: process.version, runnerVersion, ...defaultMeta },
-});
-
-let executionId = null;
-let projectId = null;
-
-function setExecutionId(execId) {
-    executionId = execId;
-}
-
-function setProjectId(projId) {
-    projectId = projId;
-}
-
-function setProxyUri(proxyUri) {
-    if (config.IS_ON_PREM || !proxyUri) {
-        return;
-    }
-    const { CoralogixTransport } = require('../lib/coralogix-winston.transport');
-    CoralogixTransport.configure({ ...loggerConfig, proxyUri });
-}
-
-function releaseFlags() {
-    return {
-        release: true,
-        branch: 'production',
-    };
-}
-
-function devFlags() {
-    return {
-        release: false,
-        branch: 'test',
-    };
-}
-
-function localFlags() {
-    return {
-        release: false,
-        branch: 'local',
-    };
-}
-
-function addExecutionMetadata(dataExecutionId) {
-    const logData = {};
-    if (executionId && !dataExecutionId) {
-        logData.executionId = executionId;
-    }
-
-    logData.projectId = projectId;
-    logData.time = (new Date()).toISOString();
-
-    return logData;
-}
-
-class Logger {
-    constructor(logger) {
-        this._logger = logger;
-        this.debug = this.debug.bind(this);
-        this.info = this.info.bind(this);
-        this.warn = this.warn.bind(this);
-        this.error = this.error.bind(this);
-        this.fatal = this.fatal.bind(this);
-    }
-
-    debug(msg, data = {}) {
-        this.innerLog('debug', msg, data);
-    }
-
-    info(msg, data = {}) {
-        this.innerLog('info', msg, data);
-    }
-
-    warn(msg, data = {}) {
-        this.innerLog('warning', msg, data);
-    }
-
-    error(msg, data = {}) {
-        this.innerLog('error', msg, data);
-    }
-
-    fatal(msg, data = {}) {
-        this.innerLog('crit', msg, data);
-    }
-
-    innerLog(logLevel, msg, data = {}) {
-        try {
-            this._logger.log(logLevel, Object.assign({ meta: data }, { message: msg }, addExecutionMetadata(data.executionId)));
-        } catch (err) {
-            try {
-                this._logger.log('crit', Object.assign({ message: `failed to log message ${err.message}, ${err.stack}` }, addExecutionMetadata(data.executionId)));
-            } catch (_err) {
-                // well what can we do
-            }
-        }
-    }
-
-    waitForFlush() {
-        return waitForFlush();
-    }
-}
-
-function getLogger(loggerName) {
-    return new Logger(winstonMainLogger.child({ category: loggerName }));
-}
-
-module.exports = {
-    getLogger,
-    setExecutionId,
-    setProjectId,
-    setProxyUri,
-};

package/commons/mockNetworkRuleFileSchema.json

@@ -1,140 +0,0 @@
-{
-    "$schema": "http://json-schema.org/draft-07/schema#",
-    "definitions": {
-        "request": {
-            "type": "object",
-            "required": ["url"],
-            "additionalProperties": false,
-            "properties": {
-                "url": { "type": "string" },
-                "method": {
-                    "type": "string",
-                    "pattern": "^GET$|^HEAD$|^POST$|^PUT$|^DELETE$|^CONNECT$|^OPTIONS$|^TRACE$|^PATCH$"
-                }
-            }
-        },
-        "header": {
-            "type": "object",
-            "required": [
-                "name",
-                "value"
-            ],
-            "additionalProperties": false,
-            "properties": {
-                "name": {
-                    "type": "string"
-                },
-                "value": {
-                    "type": "string"
-                }
-            }
-        },
-        "cookie": {
-            "type": "object",
-            "required": [
-                "name",
-                "value"
-            ],
-            "additionalProperties": false,
-            "properties": {
-                "name": {
-                    "type": "string"
-                },
-                "value": {
-                    "type": "string"
-                },
-                "path": {
-                    "type": "string"
-                },
-                "domain": {
-                    "type": "string"
-                },
-                "expires": {
-                    "type": "string",
-                    "format": "date-time"
-                },
-                "httpOnly": {
-                    "type": "boolean"
-                },
-                "secure": {
-                    "type": "boolean"
-                }
-            }
-        },
-        "response": {
-            "type": "object",
-            "required": ["status"],
-            "additionalProperties": false,
-            "properties": {
-                "status": {
-                    "type": "integer",
-                    "minimum": 100,
-                    "exclusiveMaximum": 600
-                },
-                "headers": {
-                    "type": "array",
-                    "items": { "$ref": "#/definitions/header" }
-                },
-                "cookies": {
-                    "type": "array",
-                    "items": { "$ref": "#/definitions/cookie" }
-                },
-                "content": {
-                    "type": "object",
-                    "required": ["text"],
-                    "additionalProperties": false,
-                    "properties": {
-                        "text": {
-                            "type": "string"
-                        }
-                    }
-                }
-            }
-        },
-        "redirectResponse": {
-            "type": "object",
-            "required": ["redirectUrl"],
-            "additionalProperties": false,
-            "properties": {
-                "redirectUrl": { "type": "string" }
-            }
-        },
-        "passthroughResponse": {
-            "type": "object",
-            "required": ["passthrough"],
-            "additionalProperties": false,
-            "properties": {
-                "passthrough": { "type": "boolean", "enum": [ true ] }
-            }
-        },
-        "entry": {
-            "type": "object",
-            "required": ["request", "response"],
-            "additionalProperties": false,
-            "properties": {
-                "request": { "$ref": "#/definitions/request" },
-                "response": {
-                    "oneOf": [
-                        { "$ref": "#/definitions/response" },
-                        { "$ref": "#/definitions/redirectResponse" },
-                        { "$ref": "#/definitions/passthroughResponse" }
-                    ]
-                },
-                "maxHits": {
-                    "type": "integer",
-                    "minimum": 1
-                }
-            }
-        }
-    },
-    "type": "object",
-    "required": ["entries"],
-    "properties": {
-        "version": { "type": "string", "enum": ["1.2", "1.2.0"] },
-        "creator": { "type": "string" },
-        "entries": {
-            "type": "array",
-            "items": { "$ref": "#/definitions/entry" }
-        }
-    }
-}

package/commons/npmWrapper.js

@@ -1,174 +0,0 @@
-
-const util = require('util');
-const { additionalLogDetails } = require('./logUtils');
-const exec = util.promisify(require('child_process').exec);
-const spawn = require('child_process').spawn;
-const path = require('path');
-const { NpmPackageError, NpmPermissionsError } = require('../errors');
-const fse = require('fs-extra');
-const logger = require('./logger').getLogger('cli-service');
-const { requireWithFallback } = require('./requireWithFallback');
-const fs = require('fs');
-const utils = require('../utils');
-
-async function getLatestPackageVersion(packageName) {
-    const result = await exec(`npm view ${packageName} version`);
-    return result.stdout.trim();
-}
-
-function getPackageIfInstalledLocally(packageName) {
-    try {
-        // note: this code fails if require itself throws here
-        // rather than an ENOENT - but since lazy dependencies are all controlled
-        // by us that's probably fine.
-        return requireWithFallback(packageName);
-    } catch (err) {
-        return false;
-    }
-}
-
-async function isPackageInstalledInPath(rootPath, packageName) {
-    try {
-        return await fse.pathExists(path.join(rootPath, `./node_modules/${packageName}/package.json`));
-    } catch (error) {
-        return false;
-    }
-}
-
-function getLocallyInstalledPackageVersion(rootPath, packageName) {
-    // eslint-disable-next-line import/no-dynamic-require
-    return require(path.join(rootPath, `./node_modules/${packageName}/package.json`)).version;
-}
-
-// this is not exactly correct, but it's good enough.
-async function fileExists(path) {
-    try {
-        await fs.promises.access(path);
-        return true;
-    } catch (err) {
-        return false;
-    }
-}
-
-async function installPackageLocally(rootPath, packageName, execOptions) {
-    function getPathWithMissingPermissions(error) {
-        const pathRegex = /EACCES[^']+'(.+)'/;
-        const regexResult = pathRegex.exec(error.stderr);
-        if (regexResult === null) {
-            return false;
-        }
-        return regexResult[1];
-    }
-
-    // https://github.com/npm/arborist/pull/362
-    function npmSevenAndEightMissingPermissions(error) {
-        return /The "to" argument must be of type string./.exec(error.stderr);
-    }
-
-    // this is here because our shrinkwrap blocks our lazy deps for some reason
-    const oldShrinkwrap = path.join(rootPath, 'npm-shrinkwrap.json');
-    const newShrinkwrap = path.join(rootPath, 'npm-shrinkwrap-dummy.json');
-    let renamed = false;
-    try {
-        try {
-            if (await fileExists(oldShrinkwrap)) {
-                await fs.promises.rename(oldShrinkwrap, newShrinkwrap);
-                renamed = true;
-            }
-        } catch (err) {
-            // ignore error
-        }
-        return await exec(`npm i ${packageName} --no-save --no-prune --prefer-offline --no-audit --progress=false`, { ...execOptions, cwd: rootPath }).catch(err => {
-            const pathWithMissingPermissions = getPathWithMissingPermissions(err);
-            const npmEightMissingPermissions = npmSevenAndEightMissingPermissions(err);
-            if (pathWithMissingPermissions || npmEightMissingPermissions) {
-                logger.info('Failed to install package due to insufficient write access', {
-                    ...additionalLogDetails(),
-                    package: packageName,
-                    path: pathWithMissingPermissions || rootPath,
-                });
-                // eslint-disable-next-line no-console
-                console.error(`
-
-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 ${pathWithMissingPermissions || rootPath}
-
-`);
-                throw new NpmPermissionsError(pathWithMissingPermissions || rootPath);
-            }
-            throw err;
-        });
-    } finally {
-        if (renamed) {
-            try {
-                await fs.promises.rename(newShrinkwrap, oldShrinkwrap);
-            } catch (err) {
-                // ignore error
-            }
-        }
-    }
-}
-
-const localNpmLocation = path.resolve(require.resolve('npm').replace('index.js', ''), 'bin', 'npm-cli.js');
-
-function installPackages(prefix, packageNames, proxyUri, timeoutMs) {
-    return new Promise((resolve, reject) => {
-        const proxyFlag = proxyUri ? ['--proxy', proxyUri] : [];
-
-        const envVars = proxyUri ? { env: Object.assign(process.env, { HTTP_PROXY: proxyUri, HTTPS_PROXY: proxyUri }) } : {};
-
-        let stdout = '';
-        let stderr = '';
-
-        const ops = '--no-save --no-package-lock --no-prune --prefer-offline --no-audit --progress=false'.split(' ');
-        const npmInstall = spawn('node', [localNpmLocation, 'i', '--prefix', prefix, ...ops, ...packageNames, ...proxyFlag], envVars);
-        npmInstall.stderr.pipe(process.stderr);
-        npmInstall.stdout.pipe(process.stdout);
-
-        npmInstall.stdout.on('data', (data) => {
-            stdout += data;
-        });
-
-        npmInstall.stderr.on('data', (data) => {
-            stderr += data;
-        });
-
-        npmInstall.on('close', (code) => {
-            if (code) {
-                let errorString;
-                try {
-                    const packageVersion = /npm ERR! 404 {2}'(.+)' is not in the npm registry/gm.exec(stderr)[1];
-                    const packageName = packageVersion.split('@')[0];
-                    errorString = `404 Not Found - GET https://registry.npmjs.org/${packageName} - Not found`;
-                } catch (err) {
-                    errorString = `Npm Install closed with exit code ${code}\n stdout: ${stdout} stderr: ${stderr}`;
-                }
-
-                logger.debug(`Npm Install closed with exit code ${code}`, { message: errorString });
-
-                reject(new NpmPackageError(errorString));
-            } else {
-                resolve(stdout);
-            }
-        });
-
-        setTimeout(() => {
-            try {
-                npmInstall.kill();
-            } finally {
-                reject(new utils.TimeoutError());
-            }
-        }, timeoutMs);
-    });
-}
-
-module.exports = {
-    isPackageInstalledInPath,
-    getLatestPackageVersion,
-    getPackageIfInstalledLocally,
-    getLocallyInstalledPackageVersion,
-    installPackageLocally,
-    installPackages,
-    NpmPermissionsError,
-};