@testim/testim-cli 3.234.0 → 3.237.0

package/commons/testimNgrok.test.js

@@ -0,0 +1,140 @@
+/* eslint-disable no-console */
+
+'use strict';
+
+const { ArgError } = require('../errors.js');
+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);
+        });
+    });
+});

package/commons/testimTunnel.js

@@ -3,7 +3,7 @@
 const ora = require('ora');
 
 const LambdatestService = require('../services/lambdatestService');
-const { registerExitHook } = require('../processHandler');
+const processHandler = require('../processHandler');
 const testimCustomToken = require('./testimCustomToken');
 const { gridTypes } = require('./constants');
 const testimNgrok = require('./testimNgrok');
@@ -59,10 +59,10 @@ const disconnect = async (options) => {
     }
 };
 
-const serveTunneling = async (options) => {
-    await connect(options);
-    registerExitHook(() => disconnect(options));
-    return await new Promise(() => { /* avoid exiting process */ });
+const serveTunneling = async (options, waitFor = new Promise(() => { /* avoid exiting process */ })) => {
+    await module.exports.connect(options);
+    processHandler.registerExitHook(() => module.exports.disconnect(options));
+    return await waitFor;
 };
 
 module.exports = {

package/commons/testimTunnel.test.js

@@ -1,49 +1,67 @@
 const { expect, sinon } = require('../../test/utils/testUtils');
 const LambdatestService = require('../services/lambdatestService');
+const processHandler = require('../processHandler');
 const testimNgrok = require('./testimNgrok');
+const testimCloudflare = require('./testimCloudflare');
 const testimTunnel = require('./testimTunnel');
 
 describe('testimTunnel', () => {
     describe('connect', () => {
         let ltConnectStub;
         let ngrokConnectStub;
+        let cloudflareConnectStub;
+
         beforeEach(() => {
             ltConnectStub = sinon.stub(LambdatestService, 'connectTunnel').resolves();
             ngrokConnectStub = sinon.stub(testimNgrok, 'connectTunnel').resolves();
+            cloudflareConnectStub = sinon.stub(testimCloudflare, 'connectTunnel').resolves();
         });
         afterEach(() => {
             ltConnectStub.restore();
             ngrokConnectStub.restore();
+            cloudflareConnectStub.restore();
         });
 
         it('should not connect to tunnel if tunnel option off', async () => {
             await testimTunnel.connect({});
             sinon.assert.notCalled(ltConnectStub);
             sinon.assert.notCalled(ngrokConnectStub);
+            sinon.assert.notCalled(cloudflareConnectStub);
         });
 
         it('should choose ngrok if passed grid is not a lambdatest grid', async () => {
             await testimTunnel.connect({ tunnel: true, gridData: { } });
             sinon.assert.notCalled(ltConnectStub);
             sinon.assert.calledOnce(ngrokConnectStub);
+            sinon.assert.notCalled(cloudflareConnectStub);
+        });
+
+        it('should choose cloudflare if passed tunnelRoutes options', async () => {
+            await testimTunnel.connect({ tunnel: true, tunnelRoutes: [] });
+            sinon.assert.notCalled(ltConnectStub);
+            sinon.assert.notCalled(ngrokConnectStub);
+            sinon.assert.calledOnce(cloudflareConnectStub);
         });
 
         it('should choose lambdatest if passed grid is a lambdatest grid', async () => {
             await testimTunnel.connect({ tunnel: true, gridData: { type: 'testimLambdaTest' } });
             sinon.assert.calledOnce(ltConnectStub);
             sinon.assert.notCalled(ngrokConnectStub);
+            sinon.assert.notCalled(cloudflareConnectStub);
         });
 
         it('should choose lambdatest if passed grid is a hybrid grid', async () => {
             await testimTunnel.connect({ tunnel: true, gridData: { type: 'testimHybrid' } });
             sinon.assert.calledOnce(ltConnectStub);
             sinon.assert.notCalled(ngrokConnectStub);
+            sinon.assert.notCalled(cloudflareConnectStub);
         });
 
         it('should choose ngrok if passed grid is a hybrid grid and it is set to use ngrok tunnel', async () => {
             await testimTunnel.connect({ tunnel: true, gridData: { type: 'testimHybrid', tunnel: 'ngrok' } });
             sinon.assert.notCalled(ltConnectStub);
             sinon.assert.calledOnce(ngrokConnectStub);
+            sinon.assert.notCalled(cloudflareConnectStub);
         });
 
         it('should handle connect errors', async () => {
@@ -55,43 +73,59 @@ describe('testimTunnel', () => {
     describe('disconnect', () => {
         let ltDisconnectStub;
         let ngrokDisconnectStub;
+        let cloudflareDisconnectStub;
+
         beforeEach(() => {
             ltDisconnectStub = sinon.stub(LambdatestService, 'disconnectTunnel').resolves();
             ngrokDisconnectStub = sinon.stub(testimNgrok, 'disconnectTunnel').resolves();
+            cloudflareDisconnectStub = sinon.stub(testimCloudflare, 'disconnectTunnel').resolves();
         });
         afterEach(() => {
             ltDisconnectStub.restore();
             ngrokDisconnectStub.restore();
+            cloudflareDisconnectStub.restore();
         });
 
         it('should not disconnect from tunnel if tunnel option off', async () => {
             await testimTunnel.disconnect({});
             sinon.assert.notCalled(ltDisconnectStub);
             sinon.assert.notCalled(ngrokDisconnectStub);
+            sinon.assert.notCalled(cloudflareDisconnectStub);
         });
 
         it('should choose ngrok if passed grid is not a lambdatest grid', async () => {
             await testimTunnel.disconnect({ tunnel: true, gridData: { } });
             sinon.assert.notCalled(ltDisconnectStub);
             sinon.assert.calledOnce(ngrokDisconnectStub);
+            sinon.assert.notCalled(cloudflareDisconnectStub);
+        });
+
+        it('should choose cloudflare if passed tunnelRoutes options', async () => {
+            await testimTunnel.disconnect({ tunnel: true, tunnelRoutes: [] });
+            sinon.assert.notCalled(ltDisconnectStub);
+            sinon.assert.notCalled(ngrokDisconnectStub);
+            sinon.assert.calledOnce(cloudflareDisconnectStub);
         });
 
         it('should choose lambdatest if passed grid is a lambdatest grid', async () => {
             await testimTunnel.disconnect({ tunnel: true, gridData: { type: 'testimLambdaTest' } });
             sinon.assert.calledOnce(ltDisconnectStub);
             sinon.assert.notCalled(ngrokDisconnectStub);
+            sinon.assert.notCalled(cloudflareDisconnectStub);
         });
 
         it('should choose lambdatest if passed grid is a hybrid grid', async () => {
             await testimTunnel.disconnect({ tunnel: true, gridData: { type: 'testimHybrid' } });
             sinon.assert.calledOnce(ltDisconnectStub);
             sinon.assert.notCalled(ngrokDisconnectStub);
+            sinon.assert.notCalled(cloudflareDisconnectStub);
         });
 
         it('should choose ngrok if passed grid is a hybrid grid and it is set to use ngrok tunnel', async () => {
             await testimTunnel.disconnect({ tunnel: true, gridData: { type: 'testimHybrid', tunnel: 'ngrok' } });
             sinon.assert.notCalled(ltDisconnectStub);
             sinon.assert.calledOnce(ngrokDisconnectStub);
+            sinon.assert.notCalled(cloudflareDisconnectStub);
         });
 
         it('should handle connect errors', async () => {
@@ -99,4 +133,39 @@ describe('testimTunnel', () => {
             await expect(testimTunnel.disconnect({ tunnel: true, gridData: { type: 'testimLambdaTest' } })).to.be.rejectedWith('catch error - failed to close tunnel');
         });
     });
+
+    describe('serveTunneling', () => {
+        let connectStub;
+        let disconnectStub;
+        let registerExitHookStub;
+        let exitHooks;
+
+        beforeEach(() => {
+            exitHooks = [];
+            connectStub = sinon.stub(testimTunnel, 'connect').resolves();
+            disconnectStub = sinon.stub(testimTunnel, 'disconnect').resolves();
+            registerExitHookStub = sinon.stub(processHandler, 'registerExitHook').callsFake(cb => { exitHooks.push(cb); });
+        });
+        afterEach(() => {
+            connectStub.restore();
+            registerExitHookStub.restore();
+            disconnectStub.restore();
+        });
+
+        it('should connect to tunnel', async () => {
+            await testimTunnel.serveTunneling({}, Promise.resolve());
+            sinon.assert.calledOnce(connectStub);
+        });
+
+        it('should disconnect from tunnel on exit', async () => {
+            await testimTunnel.serveTunneling({}, Promise.resolve());
+            sinon.assert.calledOnce(registerExitHookStub);
+            exitHooks[0]();
+            sinon.assert.calledOnce(disconnectStub);
+        });
+
+        it('should return a default promise that never resolves', async () => {
+            expect(testimTunnel.serveTunneling({})).to.be.an.instanceof(Promise);
+        });
+    });
 });

package/executionQueue.js

@@ -7,6 +7,10 @@ class ExecutionQueue {
         this._waitingTests = testList.map(testInfo => new TestRun(executionId, executionName, testInfo, options, branchToUse, testStatus));
     }
 
+    stop() {
+        this._waitingTests = [];
+    }
+
     getNext() {
         const nextTestRunHandler = this._waitingTests.shift();
         if (nextTestRunHandler) {