@testim/testim-cli 3.235.0 → 3.236.0

package/agent/server.js

@@ -54,7 +54,7 @@ function initServer({
         /**
          * Init testim auth for making services request.
          */
-        let initFn = () => {};
+        let initFn = () => { };
         if (project) {
             testimCustomToken.init(project, token);
             initFn = (app) => {
@@ -99,7 +99,7 @@ function initServer({
                 case 'EPERM':
                     return reject(new ArgError(`Port ${agentPort} requires elevated privileges`));
                 case 'EADDRINUSE':
-                    return reject(new ArgError(`Port ${agentPort} is already in use`));
+                    return reject(new ArgError(`Port ${agentPort} is already in use, is another Testim instance running?`));
                 default:
                     return reject(error);
             }

package/cli.js

@@ -72,11 +72,9 @@ function main() {
                 const codimCli = require('./codim/codim-cli');
                 return codimCli.init(options.initTestProject);
             }
-
             if (options.loginMode) {
                 return undefined;
             }
-
             if (options.createPrefechedData) {
                 const runnerFileCache = require('./commons/runnerFileCache');
                 await runnerFileCache.clear();

package/cliAgentMode.js

@@ -1,3 +1,4 @@
+/* eslint-disable camelcase */
 // @ts-check
 
 'use strict';
@@ -8,12 +9,15 @@ const fs = require('fs-extra');
 const ms = require('ms');
 const WebSocket = require('ws');
 const Bluebird = require('bluebird');
+const ChromeLauncher = require('chrome-launcher');
 const httpRequest = require('./commons/httpRequest');
 const config = require('./commons/config');
 const { ArgError } = require('./errors');
 const lazyRequire = require('./commons/lazyRequire');
 const prepareUtils = require('./commons/prepareRunnerAndTestimStartUtils');
 const { unzipFile } = require('./utils');
+const { downloadAndSave } = require('./utils');
+const ora = require('ora');
 
 const LOG_LEVEL = config.WEBDRIVER_DEBUG ? 'verbose' : 'silent';
 const EXTENSION_CACHE_TIME = ms('1h');
@@ -49,7 +53,6 @@ async function runAgentMode(options) {
 
     if (options.startTestimBrowser) {
         await getRidOfPossiblyRunningChromeWithOurDataDir();
-
         try {
             // Consider moving that into the agent server and add endpoint to start browser?
             testimStandaloneBrowser = await startTestimStandaloneBrowser(options);
@@ -81,7 +84,7 @@ async function runAgentMode(options) {
             ];
 
             for (const packageToInstall of packages) {
-                await lazyRequire(packageToInstall, { silent: true }).catch(() => {});
+                await lazyRequire(packageToInstall, { silent: true }).catch(() => { });
             }
         }, LOAD_PLAYER_DELAY);
     }
@@ -108,10 +111,115 @@ function getStartedWithStart() {
     return startedWithStart;
 }
 
-async function startTestimStandaloneBrowser(options) {
-    const ora = require('ora');
-    const { downloadAndSave } = require('./utils');
+function getCurrentPlatform() {
+    const osType = os.type().toLowerCase();
+    if (osType === 'darwin') {
+        return os.arch() === 'arm' ? 'mac_arm' : 'mac';
+    }
+    if (osType === 'windows_nt') {
+        return os.arch() === 'x64' ? 'win64' : 'win32';
+    }
+    return 'linux';
+}
+async function downloadAndInstallChrome(platform, revision, saveLocation) {
+    // Inspired by puppeteer's implementation https://github.com/puppeteer/puppeteer/blob/main/src/node/BrowserFetcher.ts#L45
+    // example download url: https://storage.googleapis.com/chromium-browser-snapshots/Mac/1000968/chrome-mac.zip
+    const storageBaseUrl = 'https://storage.googleapis.com/chromium-browser-snapshots';
+    const platformFolder = {
+        linux: 'Linux_x64',
+        mac: 'Mac',
+        mac_arm: 'Mac_Arm',
+        win32: 'Win',
+        win64: 'Win_x64',
+    };
+    if (!(platform in platformFolder)) {
+        throw new ArgError(`Unsupported platform: ${platform}`);
+    }
+    // Windows archive name changed at r591479.
+    const winArchiveName = parseInt(revision, 10) > 591479 ? 'chrome-win' : 'chrome-win32';
+    const platformArchiveName = {
+        linux: 'chrome-linux',
+        mac: 'chrome-mac',
+        mac_arm: 'chrome-mac',
+        win32: winArchiveName,
+        win64: winArchiveName,
+    };
+    const binaryPaths = {
+        linux: 'chrome',
+        mac: 'Chromium.app/Contents/MacOS/Chromium',
+        mac_arm: 'Chromium.app/Contents/MacOS/Chromium',
+        win32: 'chrome.exe',
+        win64: 'chrome.exe',
+    };
+    const downloadUrl = `${storageBaseUrl}/${platformFolder[platform]}/${revision}/${platformArchiveName[platform]}.zip`;
+    const downloadArchivePath = path.join(saveLocation, platformArchiveName[platform]);
+    const downloadedZipFile = `${downloadArchivePath}.zip`;
+    const binaryPath = path.join(downloadArchivePath, binaryPaths[platform]);
 
+    if (await fs.pathExists(binaryPath)) {
+        return binaryPath;
+    }
+    if (!(await fs.pathExists(downloadedZipFile))) {
+        const downloadSpinner = ora('Downloading Chromium').start();
+        try {
+            await fs.mkdirp(saveLocation);
+            await downloadAndSave(downloadUrl, downloadedZipFile);
+            // todo - We can add a failover here if the download fails if we host the file too
+        } catch (e) {
+            const errorMessage = `Failed to download Chromium: ${e.message}`;
+            downloadSpinner.fail(errorMessage);
+            throw new Error(errorMessage);
+        }
+        downloadSpinner.succeed();
+    }
+    const extractSpinner = ora('Extracting Chromium').start();
+    try {
+        await unzipFile(downloadedZipFile, saveLocation);
+    } catch (e) {
+        const errorMessage = `Failed to extract Chromium: ${e.message}`;
+        extractSpinner.fail(errorMessage);
+        throw new Error(errorMessage);
+    }
+    extractSpinner.succeed();
+    return binaryPath;
+}
+
+async function startFixedVersionBrowser(options, extensionBase64, downloadedExtensionPathUnzipped) {
+    const CHROME_VERSION = '1000968';
+    const DOWNLOAD_CHROME_FOLDER = path.join(TESTIM_BROWSER_PROFILES_CONTAINER, `chrome-${CHROME_VERSION}`);
+
+    const chromeBinary = await downloadAndInstallChrome(getCurrentPlatform(), CHROME_VERSION, DOWNLOAD_CHROME_FOLDER);
+
+    if (!(await fs.pathExists(USER_DATA_DIR))) {
+        await fs.mkdirp(USER_DATA_DIR);
+    }
+    const capabilities = buildSeleniumOptions(USER_DATA_DIR, extensionBase64, downloadedExtensionPathUnzipped, chromeBinary);
+    const chromeFlags = [
+        ...capabilities.desiredCapabilities.chromeOptions.args,
+        ...ChromeLauncher.Launcher.defaultFlags().filter(flag => ![
+            '--disable-extensions',
+            '--disable-component-extensions-with-background-pages', // causes google connect to disallow some accounts (eg gmail accounts get a "This browser or app may not be secure" error)
+        ].includes(flag)),
+    ];
+    // Chromium needs API keys to communicate with google APIs (https://www.chromium.org/developers/how-tos/api-keys/)
+    // These are keys are keys that were included in some chrome builds
+    const envVars = {
+        GOOGLE_API_KEY: 'AIzaSyCkfPOPZXDKNn8hhgu3JrA62wIgC93d44k',
+        GOOGLE_DEFAULT_CLIENT_ID: '811574891467.apps.googleusercontent.com',
+        GOOGLE_DEFAULT_CLIENT_SECRET: 'kdloedMFGdGla2P1zacGjAQh',
+    };
+    const appUrl = `${options.extensionPath ? 'http://localhost:3000/app/' : 'https://app.testim.io'}?startMode=true`;
+    const chrome = await ChromeLauncher.launch({ chromeFlags, startingUrl: appUrl, ignoreDefaultFlags: true, userDataDir: USER_DATA_DIR, chromePath: chromeBinary, envVars });
+    const onBrowserClosed = () => process.exit(0);
+
+    chrome.process.once('exit', onBrowserClosed);
+    chrome.process.once('close', onBrowserClosed);
+    return {
+        webdriverApi: chrome,
+    };
+}
+
+async function startTestimStandaloneBrowser(options) {
     // After next clickim release we will have also testim-full.zip
     // const fullExtensionUrl = "https://testimstatic.blob.core.windows.net/extension/testim-full-master.zip";
     // CDN url
@@ -128,7 +236,6 @@ async function startTestimStandaloneBrowser(options) {
         const stat = await fs.stat(downloadedExtensionPath);
         shouldDownloadExtension = (Date.now() - EXTENSION_CACHE_TIME > stat.mtimeMs);
     }
-
     await fs.mkdirp(TESTIM_BROWSER_PROFILES_CONTAINER);
 
     if (shouldDownloadExtension) {
@@ -144,27 +251,31 @@ async function startTestimStandaloneBrowser(options) {
             await downloadAndSave(fullExtensionUrl, downloadedExtensionPath);
             try {
                 await unzipFile(downloadedExtensionPath, downloadedExtensionPathUnzipped);
-            } catch (e) {
+            } catch (err) {
                 // zip is bad again.
                 await fs.remove(downloadedExtensionPath);
                 spinner.fail('Failed to download Testim Editor');
                 throw new Error('Failed to download Testim Editor');
             }
         } finally {
-            await fs.remove(downloadedExtensionPathUnzipped);
+            if (!options.downloadBrowser) {
+                await fs.remove(downloadedExtensionPathUnzipped);
+            }
         }
 
         spinner.succeed();
     }
 
     const extensionBase64 = options.extensionPath ? null : (await fs.readFile(options.ext || downloadedExtensionPath)).toString('base64');
-
+    if (options.downloadBrowser) {
+        return await startFixedVersionBrowser(options, extensionBase64, downloadedExtensionPathUnzipped);
+    }
     await prepareUtils.prepareChromeDriver(
         { projectId: options.project },
-        { chromeBinaryLocation: options.chromeBinaryLocation },
+        { chromeBinaryLocation: options.chromeBinaryLocations },
     );
 
-    const seleniumOptions = buildSeleniumOptions(USER_DATA_DIR, extensionBase64, options.extensionPath);
+    const seleniumOptions = buildSeleniumOptions(USER_DATA_DIR, extensionBase64, options.extensionPath, options.chromeBinaryLocations);
 
     const WebDriver = require('./player/webdriver');
     const { SeleniumPerfStats } = require('./commons/SeleniumPerfStats');
@@ -184,8 +295,7 @@ async function startTestimStandaloneBrowser(options) {
     // const { getEditorUrl } = require('./commons/testimServicesApi');
 
     startedWithStart = true;
-    const appUrl = `${options.extensionPath ? 'http://localhost:3000/app/' : 'https://app.testim.io'
-    }?startMode=true`;
+    const appUrl = `${options.extensionPath ? 'http://localhost:3000/app/' : 'https://app.testim.io'}?startMode=true`;
 
     await webdriverApi.url(appUrl);
     // save the initial URL we navigated to so we don't consider it the AuT
@@ -197,6 +307,7 @@ async function startTestimStandaloneBrowser(options) {
     } catch (e) {
         // ignore error
     }
+
     return {
         webdriverApi,
     };
@@ -206,11 +317,13 @@ async function startTestimStandaloneBrowser(options) {
  * @param {string} userDataDir
  * @param {string} fullExtensionPath
  */
-function buildSeleniumOptions(userDataDir, fullExtensionPath, unpackedExtensionPath) {
+function buildSeleniumOptions(userDataDir, fullExtensionPath, unpackedExtensionPath, chromeBinaryPath) {
     const extensions = fullExtensionPath ? [fullExtensionPath] : [];
     const args = [
-        `--user-data-dir=${userDataDir}`,
+        `--user-data-dir=${userDataDir}`, // crashes chromium, re-enable if using chrome
+        '--log-level=OFF',
         '--silent-debugger-extension-api',
+        '--no-first-run',
     ];
     if (unpackedExtensionPath) {
         args.push(`--load-extension=${unpackedExtensionPath}`);
@@ -222,6 +335,7 @@ function buildSeleniumOptions(userDataDir, fullExtensionPath, unpackedExtensionP
             chromeOptions: {
                 args,
                 extensions,
+                binary: chromeBinaryPath,
             },
             browserName: 'chrome',
         },

package/commons/chromedriverWrapper.js

@@ -17,6 +17,7 @@ const DEFAULT_DRIVER_ARGS = [
     '--disable-build-check',
     // allow any ip to connect chrome driver
     '--whitelisted-ips=0.0.0.0',
+    '--log-level=OFF', // instead we could try to log it somehow or at least have a flag to enable this
 ];
 
 // [NOTE] This is a "smart installation":

package/commons/featureFlags.js

@@ -57,6 +57,7 @@ class FeatureFlagsService {
             addCustomCapabilities: new Rox.Variant('{}'),
             enableWorkerThreadsCliCodeExecution: new Rox.Flag(true),
             LTNetworkCapabilities: new Rox.Flag(),
+            downloadToBase64: new Rox.Flag(),
         };
         Rox.register('default', this.flags);
     }

package/commons/prepareRunnerAndTestimStartUtils.js

@@ -89,11 +89,13 @@ function prepareExtension(locations) {
     const fullLocations = locations.map(location => ({ location, path: getSourcePath(location) }));
     return localRunnerCache.memoize(
         () => Promise.map(fullLocations, ({ location, path }) => getSource(location, path)),
-        'prepareExtension', MSEC_IN_HALF_DAY, fullLocations
+        'prepareExtension',
+        MSEC_IN_HALF_DAY,
+        fullLocations
     )();
 }
 
-async function prepareChromeDriver(userDetails = {}, driverOptions = {}, skipIsReadyCheck) {
+async function prepareChromeDriver(userDetails = {}, driverOptions = {}, skipIsReadyCheck = false) {
     const ora = require('ora');
     const spinner = ora('Starting Driver').start();
     const chromedriverWrapper = require('./chromedriverWrapper');
@@ -184,6 +186,8 @@ function preparePlayer(location, canary) {
         () => getPlayerLocation(location, canary)
             .then(loc => downloadAndUnzip(loc, playerFileName))
             .then(() => ({})),
-        'preparePlayer', MSEC_IN_HALF_DAY, [location, canary, playerFileName]
+        'preparePlayer',
+        MSEC_IN_HALF_DAY,
+        [location, canary, playerFileName]
     )();
 }

package/commons/testimCloudflare.js

@@ -1,10 +1,9 @@
 'use strict';
 
 const os = require('os');
-const path = require('path');
-const { spawn } = require('child_process');
+const childProcess = require('child_process');
 const fse = require('fs-extra');
-const { downloadAndSave, unzipFile } = require('../utils');
+const utils = require('../utils');
 const servicesApi = require('./testimServicesApi.js');
 
 const TUNNEL_BINARY_ORIGIN = 'https://github.com/cloudflare/cloudflared/releases/download/2022.4.1/';
@@ -33,9 +32,9 @@ async function prepareTunnel() {
         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 downloadAndSave(`${TUNNEL_BINARY_ORIGIN}/${downloadUrl.path}`, destination);
+    await utils.downloadAndSave(`${TUNNEL_BINARY_ORIGIN}/${downloadUrl.path}`, destination);
     if (downloadUrl.extract) {
-        await unzipFile(destination, TUNNEL_BINARY_DIRECTORY);
+        await utils.unzipFile(destination, TUNNEL_BINARY_DIRECTORY);
     }
     await fse.chmodSync(TUNNEL_BINARY_LOCATION, '755');
 }
@@ -43,10 +42,10 @@ async function prepareTunnel() {
 const connectTunnel = async (options) => {
     const [result] = await Promise.all([
         servicesApi.getCloudflareTunnel(options.company.companyId, options.tunnelRoutes),
-        prepareTunnel(),
+        module.exports.prepareTunnel(),
     ]);
     tunnelId = result._id;
-    tunnelProcess = spawn(TUNNEL_BINARY_LOCATION, ['tunnel', '--no-autoupdate', 'run', '--force', '--token', result.token], { stdio: 'inherit' });
+    tunnelProcess = childProcess.spawn(TUNNEL_BINARY_LOCATION, ['tunnel', '--no-autoupdate', 'run', '--force', '--token', result.token], { stdio: 'inherit' });
     await servicesApi.forceUpdateCloudflareTunnelRoutes(options.company.companyId, tunnelId);
     await fse.writeFileSync(options.tunnelRoutesOutput, JSON.stringify(result.routesMapping, null, 2));
 };
@@ -60,7 +59,7 @@ const disconnectTunnel = async (options) => {
         promises.push(new Promise((resolve, reject) => {
             tunnelProcess.on('close', (code) => {
                 if (code) {
-                    reject();
+                    reject(new Error(`tunnel process exited with code ${code}`));
                 }
                 resolve();
             });
@@ -73,4 +72,5 @@ const disconnectTunnel = async (options) => {
 module.exports = {
     connectTunnel,
     disconnectTunnel,
+    prepareTunnel,
 };

package/commons/testimCloudflare.test.js

@@ -0,0 +1,162 @@
+/* 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() });
+            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() };
+            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: {} });
+            sinon.assert.calledOnce(writeFileSyncStub);
+            expect(writeFileSyncStub.args[0][1]).to.eql(JSON.stringify(tunnelData.routesMapping));
+        });
+    });
+});

package/commons/testimNgrok.js

@@ -10,7 +10,7 @@ const WHITELISTED_TUNNEL_DOMAIN_SUFFIX = '.whitelisted-ngrok.testim.io';
 let ngrokTunnelUrl = '';
 let statsTimeout;
 
-const connectTunnel = async (options, authData) => {
+const connectTunnel = async (options, authData = {}) => {
     if (!authData.ngrokToken) {
         throw new ArgError('tunnel feature is not enabled, please contact support - info@testim.io.');
     }
@@ -27,6 +27,7 @@ const connectTunnel = async (options, authData) => {
         hostname,
     };
     if (options.tunnelHostHeader) {
+        // eslint-disable-next-line camelcase
         connectOpt.host_header = options.tunnelHostHeader;
     }
     if (options.tunnelRegion) {
@@ -46,7 +47,7 @@ const connectTunnel = async (options, authData) => {
     }
 
     if (options.tunnelDiagnostics) {
-        collectNgrokStats();
+        module.exports.collectNgrokStats();
     }
     options.baseUrl = ngrokTunnelUrl;
 };
@@ -65,7 +66,7 @@ const collectNgrokStats = async (rerun = true) => {
         logger.error('error collecting ngrok stats', { err });
     }
     if (rerun) {
-        statsTimeout = setTimeout(() => collectNgrokStats(), 10000);
+        statsTimeout = setTimeout(() => module.exports.collectNgrokStats(), 10000);
     }
 };
 
@@ -76,7 +77,7 @@ const disconnectTunnel = async (options) => {
 
     clearTimeout(statsTimeout);
     if (options.tunnelDiagnostics) {
-        await collectNgrokStats(false);
+        await module.exports.collectNgrokStats(false);
     }
     const ngrok = await lazyRequire('ngrok');
     await ngrok.disconnect(ngrokTunnelUrl);
@@ -85,4 +86,5 @@ const disconnectTunnel = async (options) => {
 module.exports = {
     connectTunnel,
     disconnectTunnel,
+    collectNgrokStats,
 };