@testim/testim-cli 3.200.0 → 3.204.0

package/OverrideTestDataBuilder.js

@@ -32,7 +32,7 @@ class OverrideTestDataBuilder {
             }
         }
         if (this.isObjectNotArray(params) && typeof params.overrideAllTestsData !== 'undefined') {
-            if (this.isObjectNotArray(params.overrideAllTestsData) && !_.isEmpty(params.overrideAllTestsData)) {
+            if (_.isObject(params.overrideAllTestsData) && !_.isEmpty(params.overrideAllTestsData)) {
                 const testNames = this.testInfoList.map(test => test.name);
                 testNames.forEach(testName => this.overrideSingeTest(testName, params.overrideAllTestsData));
                 delete params.overrideAllTestsData;

package/commons/featureFlags.js

@@ -37,7 +37,6 @@ class FeatureFlagsService {
             useSafariWebdriverVisibilityChecks: new Rox.Flag(),
             useClickimVisibilityChecks: new Rox.Flag(),
             useIEWebdriverVisibilityChecks: new Rox.Flag(),
-            enableTDKRun: new Rox.Flag(true),
             runGetElementCodeInAut: new Rox.Flag(),
             enableNpmPackageInstallUsingNpmCli: new Rox.Flag(),
             enableFrameSwitchOptimization: new Rox.Flag(),
@@ -47,8 +46,6 @@ class FeatureFlagsService {
             warnOnBadNetwork: new Rox.Flag(false),
             overrideAzureStorageUrl: new Rox.Flag(),
             useJsInputCodeInSafari: new Rox.Flag(),
-            testNameTestDataInJunitReport: new Rox.Flag(),
-            countRetries: new Rox.Flag(),
             autoSaveDownloadFileFireFox: new Rox.Flag(true),
             safariSelectOptionDispatchEventOnSelectElement: new Rox.Flag(true),
             experimentalPreCodeCompilation: new Rox.Flag(false),
@@ -57,6 +54,7 @@ class FeatureFlagsService {
             useSameBrowserForMultiTests: new LabFeatureFlag('labs'),
             highSpeedMode: new LabFeatureFlag(),
             usePortedHtml5DragDrop: new Rox.Flag(),
+            applitoolsNewIntegration: new Rox.Flag(),
         };
         Rox.register('default', this.flags);
     }

package/commons/getSessionPlayerRequire.js

@@ -1,10 +1,30 @@
-"use strict";
+'use strict';
 
 const perf = require('./performance-logger');
 
 perf.log('getSessionPlayerRequire start');
 const getSessionPlayerFolder = require('./prepareRunnerAndTestimStartUtils').getSessionPlayerFolder;
+
 const testimAppDataFolder = getSessionPlayerFolder();
-const sessionPlayer = require(require('path').join(testimAppDataFolder, "sessionPlayer.js"));
+/**
+ * @type {{
+        sessionPlayer: typeof import('../../../clickim/src/background/session/sessionPlayer').SessionPlayer;
+        utils: typeof import('../../../clickim/src/lib/utils').utils;
+        commonConstants: typeof import('../../../clickim/src/common/commonConstantsStrong');
+        locatorBuilderUtils: import('../../../clickim/src/locators/locatorBuilderUtils')['locatorBuilderUtils'];
+        assetService: import('../../../clickim/src/background/assetService')['assetService'];
+        localAssetService: import('../../../clickim/src/background/localAssetService');
+        urlUtils: import('../../../clickim/src/background/portMatch/urlUtils');
+        positionUtils: import('../../../clickim/src/lib/positionUtils');
+        visibilityUtils: import('../../../clickim/src/background/visibilityUtils');
+        apiCall: import('../../../clickim/src/common/playback/apiCall')['apiCall'];
+        stepParamBuilder: typeof import('../../../clickim/src/common/stepParamsBuilder').StepParamsBuilder;
+        stepParamExpressionEvaluator: import('../../../clickim/src/common/stepParamExpressionEvaluator');
+        manifestVersion: string | undefined;
+        EyeSdkBuilder: typeof import('../../../clickim/src/background/eyeSdkBuilder').EyeSdkBuilder
+    }}
+ */
+const sessionPlayer = require(require('path').join(testimAppDataFolder, 'sessionPlayer.js')); // eslint-disable-line import/no-dynamic-require
+
 module.exports = sessionPlayer;
 perf.log('getSessionPlayerRequire end');

package/commons/logger.js

@@ -1,7 +1,9 @@
 'use strict';
 
-const bunyan = require('bunyan');
+const winston = require('winston');
+const os = require('os');
 
+const hostname = os.hostname();
 const runnerVersion = getRunnerVersion();
 const config = require('./config');
 
@@ -24,42 +26,45 @@ function getRunnerVersion() {
 }
 
 function getStreamsAndWaitForFlushPromise() {
-    const level = config.LOGGER_DEBUG ? 'debug' : 'info';
-    const streams = [];
+    const transports = [];
 
     let waitForFlush = () => Promise.resolve();
 
     if (!config.IS_ON_PREM) {
-        const CoralogixBunyan = require('../lib/coralogix-bunyan.stream');
+        const { CoralogixTransport } = require('../lib/coralogix-winston.transport');
 
-        waitForFlush = CoralogixBunyan.CoralogixStream.waitForFlush;
-
-        CoralogixBunyan.CoralogixStream.configure(loggerConfig);
-        streams.push({
-            level,
-            stream: new CoralogixBunyan.CoralogixStream({ category: 'ROOT' }),
-            type: 'raw',
+        CoralogixTransport.configure(loggerConfig);
+        const loggerInstance = new CoralogixTransport({
+            category: 'ROOT',
         });
+        transports.push(loggerInstance);
+
+        waitForFlush = () => loggerInstance.waitForFlush();
     }
 
     if (config.LOGGER_CONSOLE) {
-        const PrettyStream = require('bunyan-prettystream');
-        const prettyStdOut = new PrettyStream();
-        prettyStdOut.pipe(process.stdout);
-        streams.push({
-            level,
-            stream: prettyStdOut,
-            type: 'raw',
-        });
+        transports.push(new winston.transports.Console({
+            format: winston.format.combine(winston.format.colorize(), winston.format.simple()),
+        }));
     }
-    return [streams, waitForFlush];
+    return [transports, waitForFlush];
 }
 
-const [streams, waitForFlush] = getStreamsAndWaitForFlushPromise();
+const [transports, waitForFlush] = getStreamsAndWaitForFlushPromise();
+const level = config.LOGGER_DEBUG ? 'debug' : 'info';
+const defaultMeta = {};
+if (isLocal.indexOf('@echo') === -1) {
+    Object.assign(defaultMeta, devFlags());
 
-const bunyanMainLogger = bunyan.createLogger({
-    name: 'runner',
-    streams,
+} 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;
@@ -77,8 +82,8 @@ function setProxyUri(proxyUri) {
     if (config.IS_ON_PREM || !proxyUri) {
         return;
     }
-    const CoralogixBunyan = require('../lib/coralogix-bunyan.stream');
-    CoralogixBunyan.CoralogixStream.configure({ ...loggerConfig, proxyUri });
+    const { CoralogixTransport } = require('../lib/coralogix-winston.transport');
+    CoralogixTransport.configure({ ...loggerConfig, proxyUri });
 }
 
 function releaseFlags() {
@@ -102,53 +107,58 @@ function localFlags() {
     };
 }
 
-function addExecutionId(logData = {}) {
-    if (executionId && !logData.executionId) {
+function addExecutionMetadata(dataExecutionId) {
+    const logData = {};
+    if (executionId && !dataExecutionId) {
         logData.executionId = executionId;
     }
 
-    logData.runnerVersion = runnerVersion;
     logData.projectId = projectId;
-    logData.nodeVersion = process.version;
-
-    if (isLocal.indexOf('@echo') === -1) {
-        Object.assign(logData, devFlags());
-
+    logData.time = (new Date()).toISOString();
 
-        return logData;
-    }
-
-    Object.assign(logData, localFlags());
     return logData;
 }
 
 class Logger {
     constructor(logger) {
         this._logger = logger;
-    }
-
-    trace(msg, data = {}) {
-        this._logger.trace(addExecutionId(data), msg);
+        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._logger.debug(addExecutionId(data), msg);
+        this.innerLog('debug', msg, data);
     }
 
     info(msg, data = {}) {
-        this._logger.info(addExecutionId(data), msg);
+        this.innerLog('info', msg, data);
     }
 
     warn(msg, data = {}) {
-        this._logger.warn(addExecutionId(data), msg);
+        this.innerLog('warning', msg, data);
     }
 
     error(msg, data = {}) {
-        this._logger.error(addExecutionId(data), msg);
+        this.innerLog('error', msg, data);
     }
 
     fatal(msg, data = {}) {
-        this._logger.fatal(addExecutionId(data), msg);
+        this.innerLog('crit', msg, data);
+    }
+
+    innerLog(level, msg, data = {}) {
+        try {
+            this._logger.log(level, 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() {
@@ -157,7 +167,7 @@ class Logger {
 }
 
 function getLogger(loggerName) {
-    return new Logger(bunyanMainLogger.child({ category: loggerName }));
+    return new Logger(winstonMainLogger.child({ category: loggerName }));
 }
 
 module.exports = {

package/commons/testimServicesApi.js

@@ -428,6 +428,19 @@ function addTestRetry({
     }), DEFAULT_REQUEST_RETRY);
 }
 
+/**
+ * @param {string} projectId
+ * @returns {Promise<import('../../../clickim/src/common/api/testimApplitoolsApi').ApplitoolsIntegrationData>}
+ */
+function getApplitoolsIntegrationData(projectId) {
+    try {
+        return getWithAuth(`/integration/applitools/v3/connected?projectId=${projectId}`);
+    } catch (err) {
+        logger.warn('could\'nt get applitools integration data.', { err });
+        return {};
+    }
+}
+
 module.exports = {
     getS3Artifact,
     getTestPlan,
@@ -459,4 +472,5 @@ module.exports = {
     getHybridGridProvider,
     loadTest,
     isTestResultCompleted,
+    getApplitoolsIntegrationData,
 };

package/executionQueue.js

@@ -3,8 +3,8 @@
 const TestRun = require('./testRunHandler.js');
 
 class ExecutionQueue {
-    constructor(executionId, testList, options, branchToUse, testStatus) {
-        this._waitingTests = testList.map(testInfo => new TestRun(executionId, testInfo, options, branchToUse, testStatus));
+    constructor(executionId, executionName, testList, options, branchToUse, testStatus) {
+        this._waitingTests = testList.map(testInfo => new TestRun(executionId, executionName, testInfo, options, branchToUse, testStatus));
     }
 
     getNext() {

package/lib/coralogix-winston.transport.js

@@ -0,0 +1,105 @@
+const { Log, Severity, CoralogixLogger } = require('@testim/coralogix-logger');
+const TransportStream = require('winston-transport');
+
+const severityMap = {
+    silly: Severity.verbose,
+    verbose: Severity.verbose,
+    info: Severity.info,
+    http: Severity.info,
+    warn: Severity.warning,
+    warning: Severity.warning,
+    error: Severity.error,
+    silent: Severity.verbose,
+    critical: Severity.critical,
+    crit: Severity.critical,
+    debug: Severity.debug,
+};
+
+class CoralogixTransport extends TransportStream {
+    constructor(options) {
+        options = Object.assign({}, CoralogixTransport.options, options);
+        super(options);
+        this.options = options;
+        this.logger = new CoralogixLogger(options.category);
+        this.name = 'Coralogix Transport';
+        if (options.timestamp) {
+            this.timestamp = options.timestamp;
+        }
+    }
+
+    log(info, callback) {
+        const { category, level, message: msg, meta: infoMeta = {}, ...restMeta } = info;
+        const meta = Object.assign({}, infoMeta, this.options.extraFields, restMeta);
+        const log = new Log();
+
+        log.severity = severityMap[level];
+        log.text = msg;
+        log.category = category;
+        if (meta.className) {
+            log.className = meta.className;
+        }
+        if (meta.methodName) {
+            log.methodName = meta.methodName;
+        }
+        if (meta.threadId) {
+            log.threadId = meta.threadId;
+        }
+        delete meta.className;
+        delete meta.methodName;
+        delete meta.threadId;
+        delete meta.category;
+        delete meta.level;
+        delete meta.message;
+        let errorOverride = false;
+        if (infoMeta instanceof Error) {
+            errorOverride = true;
+            meta.msg = infoMeta.message + infoMeta.stack;
+            if (msg) {
+                meta.msg = `${msg}\n${meta.msg}`;
+            }
+        }
+        if (infoMeta.err instanceof Error) {
+            meta.err = {
+                message: infoMeta.err.message,
+                stack: infoMeta.err.stack,
+                name: infoMeta.err.name,
+                type: infoMeta.err.type,
+                cause: infoMeta.err.cause,
+                ...infoMeta.err,
+            };
+        }
+
+        if (infoMeta.reason instanceof Error) {
+            meta.reason = {
+                message: infoMeta.reason.message,
+                stack: infoMeta.reason.stack,
+                name: infoMeta.reason.name,
+                type: infoMeta.reason.type,
+                cause: infoMeta.reason.cause,
+                ...infoMeta.reason,
+            };
+        }
+
+        // still have keys after deleting the above
+        if (Object.keys(meta).length > 0) {
+            if (msg && !errorOverride) {
+                meta.msg = msg;
+            }
+            log.text = meta;
+        }
+
+        this.logger.addLog(log);
+        callback(null, true);
+    }
+
+    waitForFlush() {
+        return this.logger.waitForFlush();
+    }
+
+    static configure(config) {
+        CoralogixLogger.configure(config);
+        CoralogixTransport.options = config;
+    }
+}
+
+module.exports.CoralogixTransport = CoralogixTransport;