@testim/testim-cli 3.289.0 → 3.290.1-beta

package/commons/socket/baseSocketServiceSocketIO.js

@@ -1,197 +0,0 @@
-'use strict';
-
-const pRetry = require('p-retry');
-const io = require('socket.io-client');
-const config = require('../config');
-const utils = require('../../utils');
-
-const MAX_SOCKET_RECONNECT_ATTEMPT = 50;
-const MAX_RECONNECT_ATTEMPT_BEFORE_SWITCH = 10;
-const EMIT_PROMISE_TIMEOUT = 5000;
-const POLLING_TRANSPORT_TIMEOUT_MS = 10 * 1000;
-
-const logger = require('../logger').getLogger('base socket service');
-
-class BaseSocketServiceSocketIO {
-    constructor() {
-        this.attempts = 0;
-        /** @type {{ [testResultId: string]: testId }} */
-        this.rooms = {};
-        /** @type {undefined | Promise<void>} */
-        this.emitPromiseQueue = undefined;
-    }
-
-    joinToMultipleResults() {
-        const testResultIds = Object.keys(this.rooms);
-        logger.info('re-join all existing rooms', { testResultIds });
-        testResultIds.forEach(resultId => {
-            const testId = this.rooms[resultId];
-            this.emitJoinRoom?.(resultId, testId);
-        });
-    }
-
-    /**
-     * @param {string} resultId
-     * @param {string} testId
-     */
-    joinRoom(resultId, testId) {
-        this.rooms[resultId] = testId;
-    }
-
-    /**
-     * @param {string} resultId
-     * @param {string} testId
-     */
-    leaveRoom(resultId) {
-        delete this.rooms[resultId];
-    }
-
-    addSocketHandlers() {
-        const socketError = (method, err) => {
-            let transport = 'websocket';
-            try {
-                transport = this._socket.io.engine.transport.name;
-            } catch (e) {
-                /* empty */
-            }
-            logger.error(`Error in SocketService websocket _${method}_ socket ${this._socket.id} ` +
-            `is ${this.url} over ${transport}. Reconnect attempts ${this.attempts}. Error is: ${err?.message}`);
-        };
-
-        this._socket.on('reconnect_attempt', (attempt) => {
-            socketError('reconnect_attempt', { message: 'reconnect attempt', attempt });
-            this.attempts++;
-            if (this.attempts === MAX_RECONNECT_ATTEMPT_BEFORE_SWITCH && !this.isAllowedWS) {
-                this._socket.io.opts.transports = ['polling'];
-                this._socket.io.opts.upgrade = false;
-            }
-            if (this.attempts >= MAX_SOCKET_RECONNECT_ATTEMPT) {
-                throw new Error('Can\'t connect to Testim Servers.\n' +
-                    `Action required: Please allow opening a websockets connection to ${config.SERVICES_HOST} in your firewall/proxy`);
-            }
-        });
-
-        this._socket.on('connect_error', (err) => {
-            socketError('connect_error', err);
-        });
-
-        this._socket.on('connect_timeout', (err) => {
-            socketError('connect_timeout', err);
-        });
-
-        this._socket.on('error', err => {
-            socketError('error', err);
-        });
-
-        this._socket.on('reconnect_error', err => {
-            if (this.prevErr && this.prevErr.type === err.type) {
-                return;
-            }
-            this.prevErr = err;
-            socketError('reconnect_error', err);
-        });
-
-        this._socket.on('reconnect', () => {
-            logger.info('reconnect to socket and re-join to rooms');
-            this.joinToMultipleResults();
-        });
-
-        this._socket.on('connect', () => {
-            this.attempts = 0;
-            if (this.isAllowedWS === undefined) {
-                this.isAllowedWS = this._socket.io.engine.transport && this._socket.io.engine.transport.name === 'websocket';
-            }
-            if (this.onConnect) {
-                this.onConnect();
-            }
-        });
-    }
-
-    /**
-     * @param {string} projectId
-     * @param {string} ns
-     */
-    initNewSocket(projectId, ns) {
-        const opts = {
-            query: { projectId },
-            requestTimeout: POLLING_TRANSPORT_TIMEOUT_MS,
-            transports: ['websocket'],
-            upgrade: false,
-            forceNew: true,
-            rejectUnauthorized: process.env.NODE_TLS_REJECT_UNAUTHORIZED !== '0',
-        };
-
-        if (global.caFileContent) {
-            opts.ca = global.caFileContent;
-        }
-
-        if (global.proxyUri) {
-            opts.agent = new global.ProxyAgent(global.proxyUri);
-        }
-
-        return new Promise(resolve => {
-            this.url = `${config.SERVICES_HOST}/${ns}`;
-            this._socket = io.connect(this.url, opts);
-            this.addSocketHandlers();
-            this._socket.on('connect', resolve);
-            this._socket.open();
-        });
-    }
-
-    /**
-     * @param {string} projectId
-     * @param {string} ns
-     */
-    init(projectId, ns) {
-        const opts = {
-            query: { projectId },
-            requestTimeout: POLLING_TRANSPORT_TIMEOUT_MS,
-            transports: ['websocket'],
-            upgrade: false,
-            rejectUnauthorized: process.env.NODE_TLS_REJECT_UNAUTHORIZED !== '0',
-        };
-
-        if (global.caFileContent) {
-            opts.ca = global.caFileContent;
-        }
-
-        if (global.proxyUri) {
-            opts.agent = new global.ProxyAgent(global.proxyUri);
-        }
-
-        this.url = `${config.SERVICES_HOST}/${ns}`;
-        this._socket = io.connect(this.url, opts);
-        this.addSocketHandlers();
-    }
-
-    /**
-     * @param {string} eventName
-     * @param {*} eventData
-     */
-    emitPromise(eventName, eventData) {
-        const errorneousEvents = {};
-
-        const emitAndWait = () => new Promise((resolve, reject) => {
-            this._socket.emit(eventName, eventData, data => {
-                if (data?.success) {
-                    return resolve();
-                }
-                errorneousEvents[eventName] = eventData;
-
-                return reject(new Error('bad ack'));
-            });
-        });
-
-        this.emitPromiseQueue = (this.emitPromiseQueue || Promise.resolve())
-            .then(() => pRetry(() => utils.promiseTimeout(emitAndWait(), EMIT_PROMISE_TIMEOUT), { retries: 200, minTimeout: 3000, factor: 1 }))
-            .finally(() => {
-                if (Object.keys(errorneousEvents).length > 0) {
-                    logger.error('Bad acknowledge from socket emit', { errorneousEvents });
-                }
-            });
-
-        return this.emitPromiseQueue;
-    }
-}
-
-module.exports = BaseSocketServiceSocketIO;

package/commons/socket/realDataService.js

@@ -1,59 +0,0 @@
-'use strict';
-
-const RealDataServiceSocketIO = require('./realDataServiceSocketIO');
-const socketService = require('./socketService');
-
-const { socketEventTypes } = require('../constants');
-const featureFlags = require('../featureFlags');
-
-const { TEST_RESULT_CREATED, TEST_RESULT_UPDATED } = socketEventTypes;
-
-class RealDataService {
-    constructor() {
-        if (featureFlags.flags.useNewWSCLI.isEnabled()) {
-            return;
-        }
-        this.realDataServiceSocketIO = new RealDataServiceSocketIO();
-    }
-
-    init(projectId) {
-        if (featureFlags.flags.useNewWSCLI.isEnabled()) {
-            return Promise.resolve();
-        }
-        return this.realDataServiceSocketIO.init(projectId);
-    }
-
-    joinToTestResultsByRunId(runId, projectId) {
-        if (featureFlags.flags.useNewWSCLI.isEnabled()) {
-            return socketService.addFilter(runId, { runId }, [
-                TEST_RESULT_UPDATED,
-                TEST_RESULT_CREATED,
-            ], true);
-        }
-        this.realDataServiceSocketIO.joinToTestResultsByRunId(runId, projectId);
-        return undefined;
-    }
-
-    stopListenToTestResultsByRunId(runId) {
-        if (featureFlags.flags.useNewWSCLI.isEnabled()) {
-            socketService.removeFilter(runId, [TEST_RESULT_UPDATED, TEST_RESULT_CREATED]);
-            return;
-        }
-        this.realDataServiceSocketIO.stopListenToTestResultsByRunId(runId);
-    }
-
-    listenToTestResultsByRunId(runId, cb) {
-        if (featureFlags.flags.useNewWSCLI.isEnabled()) {
-            socketService.listenTo(
-                runId,
-                [TEST_RESULT_UPDATED, TEST_RESULT_CREATED],
-                data => data.runId === runId,
-                data => cb(data)
-            );
-            return;
-        }
-        this.realDataServiceSocketIO.listenToTestResultsByRunId(cb);
-    }
-}
-
-module.exports = RealDataService;

package/commons/socket/realDataServiceSocketIO.js

@@ -1,33 +0,0 @@
-'use strict';
-
-const BaseSocketService = require('./baseSocketServiceSocketIO');
-
-class RealDataServiceSocketIO extends BaseSocketService {
-    init(projectId) {
-        return super.initNewSocket(projectId, 'real-data');
-    }
-
-    emitJoinRoom(runId, projectId) {
-        this._socket.emit('testResult:listen', { query: `projectId=${projectId}&runId=${runId}` });
-    }
-
-    joinToTestResultsByRunId(runId, projectId) {
-        this.joinRoom(runId, projectId);
-        this.emitJoinRoom(runId, projectId);
-    }
-
-    stopListenToTestResultsByRunId(runId) {
-        this.leaveRoom(runId);
-        this._socket.emit('testResult:listen:stop', {});
-    }
-
-    listenToTestResultsByRunId(cb) {
-        function onDone(data) {
-            cb(data.data);
-        }
-
-        this._socket.on('testResult:changes', onDone.bind(this));
-    }
-}
-
-module.exports = RealDataServiceSocketIO;

package/commons/socket/remoteStepService.js

@@ -1,55 +0,0 @@
-const socketService = require('./socketService');
-const { socketEventTypes } = require('../constants');
-const featureFlags = require('../featureFlags');
-
-const { REMOTE_STEP_SAVED } = socketEventTypes;
-
-let remoteStepServiceSocketIO; // required lazily since it takes 150ms to load
-
-class RemoteStepService {
-    init(projectId) {
-        if (featureFlags.flags.useNewWSCLI.isEnabled()) {
-            return;
-        }
-        remoteStepServiceSocketIO = require('./remoteStepServiceSocketIO');
-        remoteStepServiceSocketIO.init(projectId);
-    }
-
-    joinToRemoteStep(resultId) {
-        if (featureFlags.flags.useNewWSCLI.isEnabled()) {
-            return socketService.addFilter(`${resultId}:remoteStep`, { resultId }, [REMOTE_STEP_SAVED]);
-        }
-        return remoteStepServiceSocketIO.joinToRemoteStep(resultId);
-    }
-
-    //TODO remove after migrate to save result via RestAPI
-    saveRemoteStep(resultId, stepId, remoteStep) {
-        if (featureFlags.flags.useNewWSCLI.isEnabled()) {
-            return Promise.resolve();
-        }
-        return remoteStepServiceSocketIO.saveRemoteStep(resultId, stepId, remoteStep);
-    }
-
-    listenToRemoteStep(resultId, onRemoteStep) {
-        if (featureFlags.flags.useNewWSCLI.isEnabled()) {
-            socketService.listenTo(
-                `${resultId}:remoteStep`,
-                [REMOTE_STEP_SAVED],
-                data => data.resultId === resultId && data.remoteStep && data.remoteStep.status === 'pending',
-                data => onRemoteStep(data.remoteStep)
-            );
-            return;
-        }
-        remoteStepServiceSocketIO.listenToRemoteStep(resultId, onRemoteStep);
-    }
-
-    unlistenToRemoteStep(resultId) {
-        if (featureFlags.flags.useNewWSCLI.isEnabled()) {
-            socketService.removeFilter(`${resultId}:remoteStep`, [REMOTE_STEP_SAVED]);
-            return Promise.resolve();
-        }
-        return remoteStepServiceSocketIO.unlistenToRemoteStep(resultId);
-    }
-}
-
-module.exports = new RemoteStepService();

package/commons/socket/remoteStepServiceSocketIO.js

@@ -1,61 +0,0 @@
-'use strict';
-
-const BaseSocketService = require('./baseSocketServiceSocketIO');
-
-class RemoteStepServiceSocketIO extends BaseSocketService {
-    init(projectId) {
-        super.init(projectId, 'remoteStep');
-        this.listerers = {};
-    }
-
-    emitJoinRoom(resultId) {
-        return this.emitPromise('remoteStep:join', { resultId });
-    }
-
-    emitLeaveRoom(resultId) {
-        return this.emitPromise('remoteStep:leave', { resultId });
-    }
-
-    joinToRemoteStep(resultId) {
-        if (this.rooms[resultId]) {
-            return Promise.resolve();
-        }
-        this.joinRoom(resultId);
-        return this.emitJoinRoom(resultId);
-    }
-
-    saveRemoteStep(resultId, stepId, remoteStep) {
-        return this.emitPromise('remoteStep:save', {
-            resultId,
-            stepId,
-            remoteStep,
-        });
-    }
-
-    listenToRemoteStep(resultId, onRemoteStep) {
-        if (this.listerers[resultId]) {
-            this._socket.off('remoteStep:saved', this.listerers[resultId]);
-            delete this.listerers[resultId];
-        }
-
-        this.listerers[resultId] = data => {
-            if (data.resultId === resultId && data.remoteStep && data.remoteStep.status === 'pending') {
-                onRemoteStep(data.remoteStep);
-            }
-        };
-        this._socket.on('remoteStep:saved', this.listerers[resultId]);
-    }
-
-    unlistenToRemoteStep(resultId) {
-        if (!this.listerers[resultId]) {
-            return Promise.resolve();
-        }
-
-        this.leaveRoom(resultId);
-        this._socket.off('remoteStep:saved', this.listerers[resultId]);
-        delete this.listerers[resultId];
-        return this.emitLeaveRoom(resultId);
-    }
-}
-
-module.exports = new RemoteStepServiceSocketIO();

package/commons/socket/socketService.js

@@ -1,175 +0,0 @@
-'use strict';
-
-const WebSocket = require('ws');
-const _ = require('lodash');
-const { WEBSOCKET_HOST } = require('../config');
-const utils = require('../../utils');
-const logger = require('../logger').getLogger('socket-ng-service');
-const { EventEmitter } = require('events');
-const testimCustomToken = require('../testimCustomToken');
-
-const WAIT_BETWEEN_RECONNECT_MS = 5000;
-
-class SocketService extends EventEmitter {
-    constructor() {
-        super();
-        this.clientId = utils.guid();
-        this.ws = null;
-        this.filterMap = {};
-        this.listeners = {};
-    }
-
-    onReconnect(projectId) {
-        logger.info('test result websocket re-connect');
-        setTimeout(() => this.connect(projectId), WAIT_BETWEEN_RECONNECT_MS);
-    }
-
-    /** @param {string} url */
-    formatUrl(url) {
-        if (url.startsWith('http://')) {
-            return url.replace('http://', 'ws://');
-        }
-
-        if (url.startsWith('https://')) {
-            return url.replace('https://', 'wss://');
-        }
-
-        return url;
-    }
-
-    parseEvent(event) {
-        try {
-            return JSON.parse(event);
-        } catch (err) {
-            logger.error('failed to parse or trigger event', { err });
-        }
-        return undefined;
-    }
-
-    connect(projectId) {
-        const wsBaseUrl = this.formatUrl(WEBSOCKET_HOST);
-        return testimCustomToken.getCustomTokenV3()
-            .then(token => new Promise((resolve) => {
-                const options = {};
-                if (global.proxyUri) {
-                    options.agent = new global.ProxyAgent(global.proxyUri);
-                }
-                this.ws = new WebSocket(`${wsBaseUrl}?projectId=${projectId}&clientId=${this.clientId}&token=${token}`, options);
-
-                this.ws.on('open', () => {
-                    logger.info('websocket opened');
-                    this.reSendAllExistingFilters();
-                    if (this.onConnect) {
-                        this.onConnect();
-                    }
-                    return resolve();
-                });
-
-                this.ws.on('close', (event) => {
-                    logger.info('websocket closed', { event });
-                    if (!this.ws || this.ws.readyState === WebSocket.CLOSED) {
-                        this.onReconnect(projectId, token, wsBaseUrl);
-                    }
-                });
-
-                this.ws.on('error', (event) => {
-                    logger.info('websocket error', { event });
-                });
-
-                this.ws.on('message', (event) => {
-                    const evObject = this.parseEvent(event);
-                    if (evObject?.type) {
-                        this.emit(evObject.type, evObject.data);
-                    }
-                });
-            }));
-    }
-
-    // this is private because our sockets are supposed to be read-only to
-    // external consumers and writes need to happen through the REST API
-    // this is important since recovery of messages is the case of reconnects is
-    // done in the code calling sendMessage and not in sendMessage itself
-    sendMessage(msg) {
-        if (!this.ws) {
-            logger.warn('tried to send error when websocket was disconnected');
-            return;
-        }
-        try {
-            this.ws.send(JSON.stringify(msg));
-        } catch (err) {
-            logger.error('failed to stringify message for sending', { err });
-        }
-    }
-
-    listenOnce(eventName, eventMatcher, listener) {
-        const onEvent = (data) => {
-            if (eventMatcher(data)) {
-                listener(data);
-                this.removeListener(eventName, onEvent);
-            }
-        };
-
-        this.on(eventName, onEvent);
-    }
-
-    listenTo(key, eventName, eventMatcher, listener) {
-        //TODO - Consider doing key:value event name subscriptions here, routing inside the .on('message' into an event name based on the key and removing the listeners array.
-        function fireIfSameMatchEventMatcher(data) {
-            if (eventMatcher(data)) {
-                listener(data);
-            }
-        }
-
-        const eventNameArray = Array.isArray(eventName) ? eventName : [eventName];
-        eventNameArray.forEach(name => {
-            this.listeners[`${key}:${name}`] = this.listeners[`${key}:${name}`] || [];
-            const _listener = fireIfSameMatchEventMatcher.bind(this);
-            this.listeners[`${key}:${name}`].push(_listener);
-            this.on(name, _listener);
-        });
-    }
-
-    reSendAllExistingFilters() {
-        Object.keys(this.filterMap).forEach(key => {
-            const filter = this.filterMap[key];
-            this.sendMessage({ type: 'add-filter', filter });
-        });
-    }
-
-    addFilter(key, query, type, returnFullDocument = false) {
-        return new Promise(resolve => {
-            const filterId = utils.guid();
-            const filter = { query, id: filterId, type, fullDocument: returnFullDocument };
-            this.listenOnce('add-filter:done', data => data.id === filterId, resolve);
-            this.sendMessage({ type: 'add-filter', filter });
-            this.filterMap[key] = filter;
-        });
-    }
-
-    removeListeners(key, typeArray) {
-        if (Object.keys(this.listeners).length === 0) {
-            return;
-        }
-        typeArray.forEach(name => {
-            const listeners = this.listeners[`${key}:${name}`];
-            if (listeners) {
-                delete this.listeners[`${key}:${name}`];
-                listeners.forEach(listener => this.removeListener(name, listener));
-            }
-        });
-    }
-
-    removeFilter(key, type) {
-        const filter = this.filterMap[key];
-        if (!filter) {
-            return;
-        }
-
-        const typeArray = Array.isArray(type) ? type : [type];
-        this.removeListeners(key, typeArray);
-        delete this.filterMap[key];
-        this.sendMessage({ type: 'remove-filter', filter });
-    }
-}
-
-module.exports = new SocketService();

package/commons/socket/testResultService.js

@@ -1,62 +0,0 @@
-const testResultServiceSocketIO = require('./testResultServiceSocketIO');
-const socketService = require('./socketService');
-
-const { EventEmitter } = require('events');
-const featureFlags = require('../featureFlags');
-
-const { socketEventTypes } = require('../constants');
-
-class TestResultService extends EventEmitter {
-    init(projectId) {
-        if (featureFlags.flags.useNewWSCLI.isEnabled()) {
-            socketService.onConnect = () => this.emit('socket-connected');
-            return;
-        }
-        testResultServiceSocketIO.init(projectId);
-        testResultServiceSocketIO.onConnect = () => this.emit('socket-connected');
-    }
-
-    joinToTestResult(resultId, testId) {
-        //TODO - Consider unifying the joinToTestResult and listenToTestResult flows
-        if (featureFlags.flags.useNewWSCLI.isEnabled()) {
-            return socketService.addFilter(`${resultId}:testResult`, { resultId, testId }, [
-                socketEventTypes.TEST_RESULT_UPDATED,
-                socketEventTypes.TEST_RESULT_CREATED,
-            ]);
-        }
-        testResultServiceSocketIO.joinRoom(resultId, testId);
-        return testResultServiceSocketIO.emitJoinRoom(resultId, testId);
-    }
-
-    leaveTestResult(resultId, testId) {
-        if (featureFlags.flags.useNewWSCLI.isEnabled()) {
-            socketService.removeFilter(`${resultId}:testResult`, [socketEventTypes.TEST_RESULT_UPDATED, socketEventTypes.TEST_RESULT_CREATED]);
-            return Promise.resolve();
-        }
-
-        return testResultServiceSocketIO.leaveTestResult(resultId, testId);
-    }
-
-    listenToTestResult(resultId, testId, onTestResultStatus) {
-        if (featureFlags.flags.useNewWSCLI.isEnabled()) {
-            socketService.listenTo(
-                `${resultId}:testResult`,
-                [socketEventTypes.TEST_RESULT_UPDATED, socketEventTypes.TEST_RESULT_CREATED],
-                data => data.resultId === resultId && data.testId === testId,
-                data => onTestResultStatus(data)
-            );
-            return;
-        }
-
-        testResultServiceSocketIO.listenToTestResult(resultId, testId, onTestResultStatus);
-    }
-
-    getSocket() {
-        if (featureFlags.flags.useNewWSCLI.isEnabled()) {
-            return undefined;
-        }
-        return testResultServiceSocketIO.getSocket();
-    }
-}
-
-module.exports = new TestResultService();