@testim/testim-cli 3.289.0 → 3.290.0

package/commons/testimNgrok.js

@@ -1,90 +0,0 @@
-'use strict';
-
-const { ArgError } = require('../errors');
-const utils = require('../utils');
-const lazyRequire = require('./lazyRequire');
-const logger = require('./logger').getLogger('testimNgrok');
-
-const WHITELISTED_TUNNEL_DOMAIN_SUFFIX = '.whitelisted-ngrok.testim.io';
-
-let ngrokTunnelUrl = '';
-let statsTimeout;
-
-const connectTunnel = async (options, authData = {}) => {
-    if (!authData.ngrokToken) {
-        throw new ArgError('tunnel feature is not enabled, please contact support - info@testim.io.');
-    }
-
-    let hostname;
-    if (authData.isNgrokWhitelisted) {
-        hostname = `${utils.guid()}-${options.projectData.projectId}${WHITELISTED_TUNNEL_DOMAIN_SUFFIX}`;
-    }
-
-    const connectOpt = {
-        proto: 'http',
-        addr: options.tunnelPort || 80,
-        authtoken: authData.ngrokToken,
-        hostname,
-    };
-    if (options.tunnelHostHeader) {
-        // eslint-disable-next-line camelcase
-        connectOpt.host_header = options.tunnelHostHeader;
-    }
-    if (options.tunnelRegion) {
-        connectOpt.region = options.tunnelRegion;
-    }
-
-    const ngrok = await lazyRequire('ngrok');
-    const url = await ngrok.connect(connectOpt);
-
-    if (options.tunnelUseHttpAddress && url.startsWith('https://')) {
-        logger.info('replace https to http');
-        const newUrl = url.replace('https://', 'http://');
-
-        ngrokTunnelUrl = newUrl;
-    } else {
-        ngrokTunnelUrl = url;
-    }
-
-    if (options.tunnelDiagnostics) {
-        module.exports.collectNgrokStats();
-    }
-    options.baseUrl = ngrokTunnelUrl;
-};
-
-const collectNgrokStats = async (rerun = true) => {
-    try {
-        const ngrok = await lazyRequire('ngrok');
-        const api = ngrok.getApi();
-        const { tunnels } = await api.get({ url: 'api/tunnels', json: true });
-        const tunnel = tunnels.find(t => t.public_url === ngrokTunnelUrl);
-
-        // eslint-disable-next-line no-console
-        console.log('ngrok stats', tunnel);
-        logger.info('ngrok stats', { tunnel });
-    } catch (err) {
-        logger.error('error collecting ngrok stats', { err });
-    }
-    if (rerun) {
-        statsTimeout = setTimeout(() => module.exports.collectNgrokStats(), 10000);
-    }
-};
-
-const disconnectTunnel = async (options) => {
-    if (!ngrokTunnelUrl) {
-        return;
-    }
-
-    clearTimeout(statsTimeout);
-    if (options.tunnelDiagnostics) {
-        await module.exports.collectNgrokStats(false);
-    }
-    const ngrok = await lazyRequire('ngrok');
-    await ngrok.disconnect(ngrokTunnelUrl);
-};
-
-module.exports = {
-    connectTunnel,
-    disconnectTunnel,
-    collectNgrokStats,
-};

package/commons/testimNgrok.test.js

@@ -1,140 +0,0 @@
-/* eslint-disable no-console */
-
-'use strict';
-
-const { ArgError } = require('../errors');
-const { sinon, expect } = require('../../test/utils/testUtils');
-const testimNgrok = require('./testimNgrok');
-const utils = require('../utils');
-const npmWrapper = require('./npmWrapper');
-
-
-
-describe('testimNgrok', () => {
-    let sandbox;
-    let authData;
-    let tunnelUrl;
-    let collectNgrokStatsStub;
-
-    const ngrokMock = {
-        connect: () => {},
-        disconnect: () => {},
-        getApi: () => {},
-    };
-
-    beforeEach(() => {
-        sandbox = sinon.createSandbox();
-        authData = { ngrokToken: utils.guid() };
-        tunnelUrl = utils.guid();
-        sandbox.stub(ngrokMock, 'connect').callsFake(() => tunnelUrl);
-        sandbox.stub(ngrokMock, 'disconnect');
-        sandbox.stub(npmWrapper, 'getPackageIfInstalledLocally').returns(ngrokMock);
-        collectNgrokStatsStub = sandbox.stub(testimNgrok, 'collectNgrokStats');
-    });
-    afterEach(() => {
-        sandbox.restore();
-    });
-
-    describe('disconnectTunnel', () => {
-        it('should do nothing when no tunnel', async () => {
-            await testimNgrok.disconnectTunnel({});
-            sinon.assert.neverCalledWith(ngrokMock.disconnect);
-        });
-
-        it('should disconnect the tunnel', async () => {
-            await testimNgrok.connectTunnel({}, authData);
-            await testimNgrok.disconnectTunnel({});
-            sinon.assert.calledOnce(ngrokMock.disconnect);
-        });
-
-        it('should collect stats on disconnect', async () => {
-            await testimNgrok.connectTunnel({}, authData);
-            await testimNgrok.disconnectTunnel({ tunnelDiagnostics: true });
-
-            sinon.assert.calledOnce(collectNgrokStatsStub);
-        });
-    });
-
-    describe('connectTunnel', () => {
-        it('should throw when no token', async () => {
-            await expect(testimNgrok.connectTunnel({ company: {} })).to.be.rejectedWith(ArgError, 'tunnel feature is not enabled, please contact support - info@testim.io.');
-        });
-
-        it('should spawn the tunnel', async () => {
-            const opts = {};
-            await testimNgrok.connectTunnel(opts, authData);
-
-            sinon.assert.calledOnce(ngrokMock.connect);
-            expect(ngrokMock.connect.args[0][0]).to.shallowDeepEqual({
-                proto: 'http',
-                addr: 80,
-                authtoken: authData.ngrokToken,
-                hostname: undefined,
-            });
-            expect(opts.baseUrl).to.equal(tunnelUrl);
-        });
-
-        it('should return whitlisted url when isNgrokWhitelisted', async () => {
-            authData.isNgrokWhitelisted = true;
-            await testimNgrok.connectTunnel({ projectData: { projectId: 'projectId' } }, authData);
-            expect(ngrokMock.connect.args[0][0].hostname).to.endWith('projectId.whitelisted-ngrok.testim.io');
-        });
-
-        it('should support tunnelHostHeader', async () => {
-            const tunnelHostHeader = utils.guid();
-            await testimNgrok.connectTunnel({ tunnelHostHeader }, authData);
-            // eslint-disable-next-line camelcase
-            expect(ngrokMock.connect.args[0][0]).to.shallowDeepEqual({ host_header: tunnelHostHeader });
-        });
-
-        it('should support tunnelRegion', async () => {
-            const tunnelRegion = utils.guid();
-            await testimNgrok.connectTunnel({ tunnelRegion }, authData);
-            expect(ngrokMock.connect.args[0][0]).to.shallowDeepEqual({ region: tunnelRegion });
-        });
-
-        it('should force using http when passing tunnelUseHttpAddress', async () => {
-            const opts = { tunnelUseHttpAddress: true };
-            const guid = utils.guid();
-            tunnelUrl = `https://${guid}`;
-            await testimNgrok.connectTunnel(opts, authData);
-
-            sinon.assert.calledOnce(ngrokMock.connect);
-            expect(opts.baseUrl).to.equal(`http://${guid}`);
-        });
-
-        it('should collect stats on connect', async () => {
-            await testimNgrok.connectTunnel({ tunnelDiagnostics: true }, authData);
-            sinon.assert.calledOnce(collectNgrokStatsStub);
-        });
-    });
-
-    describe('collectNgrokStats', () => {
-        let tunnels;
-        let getApiStub;
-        beforeEach(() => {
-            tunnels = [{ }];
-            getApiStub = sandbox.stub(ngrokMock, 'getApi').returns({ get: () => ({ tunnels }) });
-            collectNgrokStatsStub.callThrough();
-        });
-
-        it('should collect stats', async () => {
-            await testimNgrok.collectNgrokStats(false);
-            sinon.assert.calledOnce(ngrokMock.getApi);
-        });
-
-        it('should rerun itself using timeout', async () => {
-            const clock = sandbox.useFakeTimers();
-
-            await testimNgrok.collectNgrokStats();
-            clock.tick(15000);
-            sinon.assert.calledTwice(collectNgrokStatsStub);
-        });
-
-        it('should ignore errors while collecting stats', async () => {
-            getApiStub.throws(new Error('test'));
-            await testimNgrok.collectNgrokStats();
-            sinon.assert.calledOnce(ngrokMock.getApi);
-        });
-    });
-});