@testim/testim-cli 3.289.0 → 3.290.1-beta

package/commons/socket/testResultServiceSocketIO.js

@@ -1,64 +0,0 @@
-'use strict';
-
-const BaseSocketService = require('./baseSocketServiceSocketIO');
-
-class TestResultServiceSocketIO extends BaseSocketService {
-    init(projectId) {
-        super.init(projectId, 'testResult');
-        this.listerers = {};
-    }
-
-    listenToTestResult(resultId, testId, onTestResultStatus) {
-        if (this.listerers[resultId]) {
-            this._socket.off('testResult:updated', this.listerers[resultId]);
-            delete this.listerers[resultId];
-        }
-
-        this.listerers[resultId] = data => {
-            if (data.resultId === resultId && data.testId === testId) {
-                onTestResultStatus(data.testResult);
-            }
-        };
-
-        this._socket.on('testResult:updated', this.listerers[resultId]);
-    }
-
-    emitJoinRoom(resultId, testId) {
-        return this.emitPromise('testResult:join', {
-            resultId,
-            testId,
-        });
-    }
-
-    joinToTestResult(resultId, testId) {
-        if (this.rooms[resultId]) {
-            return Promise.resolve();
-        }
-        this.joinRoom(resultId, testId);
-        return this.emitJoinRoom(resultId, testId);
-    }
-
-    emitLeaveRoom(resultId, testId) {
-        return this.emitPromise('testResult:leave', {
-            resultId,
-            testId,
-        });
-    }
-
-    leaveTestResult(resultId, testId) {
-        if (!this.listerers[resultId]) {
-            return Promise.resolve();
-        }
-
-        this.leaveRoom(resultId);
-        this._socket.off('testResult:updated', this.listerers[resultId]);
-        delete this.listerers[resultId];
-        return this.emitLeaveRoom(resultId, testId);
-    }
-
-    getSocket() {
-        return this._socket;
-    }
-}
-
-module.exports = new TestResultServiceSocketIO();

package/commons/testimAnalytics.js

@@ -1,40 +0,0 @@
-'use strict';
-
-/* segment.io */
-const config = require('./config');
-const Analytics = require('analytics-node');
-
-const analytics = new Analytics('sJOSIGKa5x5rJEGsaOlCjrgozAf7FnVY', { flushAt: 1 });
-
-const anonymousId = require('crypto').randomBytes(20).toString('hex');
-
-function identify(data) {
-    if (config.IS_ON_PREM) {
-        return;
-    }
-    if (!data || !data.userId) {
-        data = { anonymousId };
-    }
-    analytics.identify(data);
-}
-
-function trackWithCIUser(eventName, properties) {
-    return track('ci', eventName, properties);
-}
-
-function track(userId, eventName, properties) {
-    if (config.IS_ON_PREM) {
-        return;
-    }
-    const id = userId ? { userId } : { anonymousId };
-    analytics.track(Object.assign(id, {
-        event: eventName,
-        properties,
-    }));
-}
-
-module.exports = {
-    identify,
-    track,
-    trackWithCIUser,
-};

package/commons/testimCloudflare.js

@@ -1,83 +0,0 @@
-'use strict';
-
-const os = require('os');
-const childProcess = require('child_process');
-const fse = require('fs-extra');
-const utils = require('../utils');
-const servicesApi = require('./testimServicesApi.js');
-
-const TUNNEL_BINARY_ORIGIN = 'https://github.com/cloudflare/cloudflared/releases/download/2022.4.1/';
-const TUNNEL_BINARY_PATHNAME = {
-    win32ia32: { path: 'cloudflared-windows-386.exe' },
-    win32x64: { path: 'cloudflared-windows-amd64.exe' },
-    darwinx64: { path: 'cloudflared-darwin-amd64.tgz', extract: true },
-    linuxia32: { path: 'cloudflared-linux-386' },
-    linuxx64: { path: 'cloudflared-linux-amd64' },
-};
-const TUNNEL_BINARY_DIRECTORY = os.tmpdir();
-const TUNNEL_BINARY_LOCATION = `${TUNNEL_BINARY_DIRECTORY}/cloudflared`;
-
-
-let tunnelId = null;
-let tunnelProcess = null;
-
-async function prepareTunnel() {
-    const isBinaryExist = await fse.pathExists(TUNNEL_BINARY_LOCATION);
-    if (isBinaryExist) {
-        return;
-    }
-
-    const downloadUrl = TUNNEL_BINARY_PATHNAME[os.platform() + os.arch()];
-    if (!downloadUrl) {
-        throw new Error(`tunnel on ${os.platform() + os.arch()} platform is not supported.`);
-    }
-    const destination = downloadUrl.extract ? TUNNEL_BINARY_DIRECTORY + downloadUrl.path : TUNNEL_BINARY_LOCATION;
-    await utils.downloadAndSave(`${TUNNEL_BINARY_ORIGIN}/${downloadUrl.path}`, destination);
-    if (downloadUrl.extract) {
-        await utils.unzipFile(destination, TUNNEL_BINARY_DIRECTORY);
-    }
-    await fse.chmodSync(TUNNEL_BINARY_LOCATION, '755');
-}
-
-const connectTunnel = async (options) => {
-    const tunnelBaseUrl = options.baseUrl || `http://localhost:${options.tunnelPort || 80}`;
-    const tunnelRoutes = options.tunnelRoutes || [tunnelBaseUrl];
-    const [result] = await Promise.all([
-        servicesApi.getCloudflareTunnel(options.company.companyId, tunnelRoutes),
-        module.exports.prepareTunnel(),
-    ]);
-    tunnelId = result._id;
-    tunnelProcess = childProcess.spawn(TUNNEL_BINARY_LOCATION, ['tunnel', '--no-autoupdate', 'run', '--force', '--token', result.token], { stdio: 'inherit' });
-    await servicesApi.forceUpdateCloudflareTunnelRoutes(options.company.companyId, tunnelId);
-
-    if (options.tunnelRoutesOutput) {
-        await fse.writeFileSync(options.tunnelRoutesOutput, JSON.stringify(result.routesMapping, null, 2));
-    }
-
-    options.baseUrl = `${options.tunnelUseHttpAddress ? 'http' : 'https'}://${result.routesMapping[tunnelBaseUrl]}`;
-};
-
-const disconnectTunnel = async (options) => {
-    const promises = [];
-    if (tunnelId) {
-        promises.push(servicesApi.deleteCloudflareTunnel(options.company.companyId, tunnelId));
-    }
-    if (tunnelProcess) {
-        promises.push(new Promise((resolve, reject) => {
-            tunnelProcess.on('close', (code) => {
-                if (code) {
-                    reject(new Error(`tunnel process exited with code ${code}`));
-                }
-                resolve();
-            });
-            tunnelProcess.kill();
-        }));
-    }
-    return await Promise.all(promises);
-};
-
-module.exports = {
-    connectTunnel,
-    disconnectTunnel,
-    prepareTunnel,
-};

package/commons/testimCloudflare.test.js

@@ -1,185 +0,0 @@
-/* eslint-disable no-console */
-
-'use strict';
-
-const { sinon, expect } = require('../../test/utils/testUtils');
-const testimCloudflare = require('./testimCloudflare');
-const servicesApi = require('./testimServicesApi.js');
-const utils = require('../utils');
-const fse = require('fs-extra');
-const os = require('os');
-const childProcess = require('child_process');
-const EventEmitter = require('events');
-
-class Process extends EventEmitter {
-    constructor() {
-        super();
-    }
-    setCode(code) {
-        this.code = code;
-    }
-    kill() {
-        this.emit('close', this.code);
-    }
-}
-
-describe('testimCloudflare', () => {
-    let sandbox;
-    beforeEach(() => {
-        sandbox = sinon.createSandbox();
-    });
-    afterEach(() => {
-        sandbox.restore();
-    });
-
-    describe('disconnectTunnel', () => {
-        let deleteCloudflareTunnelStub;
-        let processMock;
-        let killStub;
-
-        beforeEach(() => {
-            deleteCloudflareTunnelStub = sandbox.stub(servicesApi, 'deleteCloudflareTunnel');
-            processMock = new Process();
-            killStub = sandbox.stub(processMock, 'kill').callThrough();
-            sandbox.stub(childProcess, 'spawn').returns(processMock);
-            sandbox.stub(testimCloudflare, 'prepareTunnel');
-            sandbox.stub(servicesApi, 'getCloudflareTunnel').resolves({ _id: utils.guid(), routesMapping: {} });
-            sandbox.stub(servicesApi, 'forceUpdateCloudflareTunnelRoutes');
-            sandbox.stub(fse, 'writeFileSync');
-        });
-
-        it('should do nothing when no tunnel', async () => {
-            await testimCloudflare.disconnectTunnel({ company: {} });
-            sinon.assert.notCalled(deleteCloudflareTunnelStub);
-        });
-
-        it('should delete the tunnel', async () => {
-            await testimCloudflare.connectTunnel({ company: {} });
-            await testimCloudflare.disconnectTunnel({ company: {} });
-            sinon.assert.calledOnce(deleteCloudflareTunnelStub);
-        });
-
-        it('should kill the tunnel', async () => {
-            await testimCloudflare.connectTunnel({ company: {} });
-            await testimCloudflare.disconnectTunnel({ company: {} });
-            sinon.assert.calledOnce(killStub);
-        });
-
-        it('should reject when killing the tunnel fails', async () => {
-            processMock.setCode(1);
-            await testimCloudflare.connectTunnel({ company: {} });
-            await expect(testimCloudflare.disconnectTunnel({ company: {} })).to.be.rejectedWith(Error);
-            sinon.assert.calledOnce(killStub);
-        });
-    });
-
-    describe('prepareTunnel', () => {
-        it('should do nothing when cloudflared binary already exists', async () => {
-            sandbox.stub(fse, 'pathExists').resolves(true);
-            const chmod = sandbox.stub(fse, 'chmodSync');
-            await testimCloudflare.prepareTunnel();
-            expect(chmod).not.to.have.been.called;
-        });
-
-        it('should throw when unsupported os', async () => {
-            sandbox.stub(fse, 'pathExists').resolves(false);
-            sandbox.stub(os, 'platform').returns('wtf');
-            sandbox.stub(os, 'arch').returns('wtf');
-
-            await expect(testimCloudflare.prepareTunnel()).to.be.rejectedWith(Error, 'tunnel on wtfwtf platform is not supported.');
-        });
-
-        it('should download cloudflared binary', async () => {
-            sandbox.stub(fse, 'pathExists').resolves(false);
-            sandbox.stub(os, 'platform').returns('win32');
-            sandbox.stub(os, 'arch').returns('x64');
-
-            const chmod = sandbox.stub(fse, 'chmodSync');
-            const download = sandbox.stub(utils, 'downloadAndSave');
-
-            await testimCloudflare.prepareTunnel();
-            sinon.assert.calledOnce(chmod);
-            sinon.assert.calledOnce(download);
-            expect(download.args[0][0]).to.startWith('https://github.com/cloudflare/cloudflared/releases/download');
-        });
-
-        it('should extract tgz file', async () => {
-            sandbox.stub(fse, 'pathExists').resolves(false);
-            sandbox.stub(os, 'platform').returns('darwin');
-            sandbox.stub(os, 'arch').returns('x64');
-            sandbox.stub(fse, 'chmodSync');
-
-            sandbox.stub(utils, 'downloadAndSave').resolves();
-            const unzip = sandbox.stub(utils, 'unzipFile').resolves();
-            await testimCloudflare.prepareTunnel();
-
-            sinon.assert.calledOnce(unzip);
-        });
-    });
-
-    describe('connectTunnel', () => {
-        let prepareTunnelStub;
-        let getCloudflareTunnelStub;
-        let forceUpdateCloudflareTunnelRoutesStub;
-        let writeFileSyncStub;
-        let spawnStub;
-
-        let tunnelData;
-
-        beforeEach(() => {
-            tunnelData = { _id: utils.guid(), token: utils.guid(), routesMapping: {} };
-            prepareTunnelStub = sandbox.stub(testimCloudflare, 'prepareTunnel');
-            getCloudflareTunnelStub = sandbox.stub(servicesApi, 'getCloudflareTunnel').resolves(tunnelData);
-            forceUpdateCloudflareTunnelRoutesStub = sandbox.stub(servicesApi, 'forceUpdateCloudflareTunnelRoutes');
-            writeFileSyncStub = sandbox.stub(fse, 'writeFileSync');
-            spawnStub = sandbox.stub(childProcess, 'spawn');
-        });
-
-        it('should prepare the tunnel', async () => {
-            await testimCloudflare.connectTunnel({ company: {} });
-            sinon.assert.calledOnce(prepareTunnelStub);
-        });
-
-        it('should get and the tunnel routes', async () => {
-            await testimCloudflare.connectTunnel({ company: {} });
-            sinon.assert.calledOnce(getCloudflareTunnelStub);
-            sinon.assert.calledWith(forceUpdateCloudflareTunnelRoutesStub);
-        });
-
-        it('should spawn the cloudflard process', async () => {
-            await testimCloudflare.connectTunnel({ company: {} });
-            sinon.assert.calledOnce(spawnStub);
-            expect(spawnStub.args[0][1]).to.eql(['tunnel', '--no-autoupdate', 'run', '--force', '--token', tunnelData.token]);
-        });
-
-        it('should write the tunnel data to a file', async () => {
-            tunnelData.routesMapping = utils.guid();
-            await testimCloudflare.connectTunnel({ company: {}, tunnelRoutesOutput: 'test.json' });
-            sinon.assert.calledOnce(writeFileSyncStub);
-            expect(writeFileSyncStub.args[0][0]).to.eql('test.json');
-            expect(writeFileSyncStub.args[0][1]).to.eql(JSON.stringify(tunnelData.routesMapping));
-        });
-
-        it('should set the baseUrl to the tunneled url', async () => {
-            tunnelData.routesMapping = { 'http://localhost:80': utils.guid() };
-            const opts = { company: {} };
-            await testimCloudflare.connectTunnel(opts);
-            expect(opts.baseUrl).to.eql(`https://${tunnelData.routesMapping['http://localhost:80']}`);
-        });
-
-        it('should set the baseUrl to the tunneled url, overriding an existing baseURL', async () => {
-            const baseUrl = utils.guid();
-            tunnelData.routesMapping = { [baseUrl]: utils.guid() };
-            const opts = { company: {}, baseUrl };
-            await testimCloudflare.connectTunnel(opts);
-            expect(opts.baseUrl).to.eql(`https://${tunnelData.routesMapping[baseUrl]}`);
-        });
-
-        it('should set the baseUrl considering tunnelUseHttpAddress', async () => {
-            tunnelData.routesMapping = { 'http://localhost:80': utils.guid() };
-            const opts = { company: {}, tunnelUseHttpAddress: true };
-            await testimCloudflare.connectTunnel(opts);
-            expect(opts.baseUrl).to.eql(`http://${tunnelData.routesMapping['http://localhost:80']}`);
-        });
-    });
-});

package/commons/testimCustomToken.js

@@ -1,124 +0,0 @@
-'use strict';
-
-const httpRequest = require('./httpRequest');
-const config = require('./config');
-const ArgError = require('../errors').ArgError;
-const logger = require('./logger').getLogger('testim-custom-token');
-const localRunnerCache = require('./runnerFileCache');
-
-let _serverToken;
-let _serverTokenExp;
-let _refreshToken;
-let _ngrokToken;
-let _isNgrokWhitelisted;
-
-let _projectId = null;
-let _token = null;
-
-const FIVE_MIN_IN_MS = 5 * 60 * 1000;
-
-async function init(projectId, token) {
-    _projectId = projectId;
-    _token = token;
-    const tokenValue = await generateToken();
-    return tokenValue;
-}
-
-function initFromData(authData, projectId, token) {
-    _serverToken = authData.token;
-    _projectId = projectId;
-    _token = token;
-    _serverTokenExp = getTokenExp(_serverToken);
-    _refreshToken = authData.refreshToken;
-    _ngrokToken = authData.ngrokToken;
-    _isNgrokWhitelisted = authData.isNgrokWhitelisted;
-}
-
-function getTokenV3(projectId = _projectId, token = _token) {
-    return localRunnerCache.memoize(() => {
-        logger.info('request to get cli token from server');
-        return httpRequest.post({
-            url: `${config.SERVICES_HOST}/auth/token`,
-            body: { projectId, token },
-        });
-    }, 'getTokenV3', FIVE_MIN_IN_MS * 10, { projectId, token })();
-}
-
-async function refreshToken() {
-    logger.info('request to refresh JWT cli token from server');
-    const customToken = await httpRequest.post({
-        url: `${config.SERVICES_HOST}/auth/refreshToken`,
-        body: { token: _serverToken, refreshToken: _refreshToken },
-    });
-    _serverToken = customToken.token;
-    _serverTokenExp = getTokenExp(_serverToken);
-    return _serverToken;
-}
-
-function generateToken() {
-    return getTokenV3()
-        .then(customToken => {
-            logger.info('successfully get cli token from server');
-            _serverToken = customToken.token;
-            _serverTokenExp = getTokenExp(_serverToken);
-            _refreshToken = customToken.refreshToken;
-            _ngrokToken = customToken.ngrokToken;
-            _isNgrokWhitelisted = customToken.isNgrokWhitelisted;
-            return _serverToken;
-        })
-        .catch(error => {
-            if (error.message.includes('Unauthorized')) {
-                throw new ArgError(
-                    'Error trying to retrieve CLI token. ' +
-                    'Your CLI token and project might not match. ' +
-                    'Please make sure to pass `--project` and `--token` that' +
-                    ' match to each other or make sure they match in your ~/.testim file.');
-            }
-            logger.error(`While trying to retrieve CLI token. caught error: ${error}`, { projectId: _projectId });
-            throw new ArgError(`While trying to retrieve CLI token, caught error: ${error}`);
-        });
-}
-
-function getTokenExp(token) {
-    const jwtLib = require('jsonwebtoken');
-    const jwt = jwtLib.decode(token);
-    return jwt.exp * 1000;
-}
-
-function getCustomTokenV3() {
-    if (!_serverTokenExp) {
-        return generateToken();
-    }
-
-    // Refresh the token earlier than needed, to give
-    // clickim a chance to have more time to run, as
-    // it can't refresh it itself.
-    if (_serverTokenExp < (Date.now() + (4 * FIVE_MIN_IN_MS))) {
-        return refreshToken().catch(err => {
-            logger.error('failed to refresh token, executing fallback', err);
-            return generateToken();
-        });
-    }
-    return Promise.resolve(_serverToken);
-}
-
-function getRefreshToken() {
-    return _refreshToken;
-}
-
-function getTokenV3UserData() {
-    if (_serverToken) {
-        const jwtLib = require('jsonwebtoken');
-        const data = jwtLib.decode(_serverToken);
-        return { uid: data.id, ngrokToken: _ngrokToken, isNgrokWhitelisted: _isNgrokWhitelisted };
-    }
-    return {};
-}
-
-module.exports = {
-    init,
-    initFromData,
-    getCustomTokenV3,
-    getTokenV3UserData,
-    getRefreshToken,
-};