@testim/testim-cli 3.194.0 → 3.198.0

package/README.md

@@ -1,6 +1,6 @@
 
 # TESTIM.IO
-## Web & Mobile Test Automation Solution. Built for agile teams. Testim is a cloud service that instantly enables Test Automation to make your Continuous Delivery ready.
+## Web Test Automation Solution. Built for agile teams. Testim is a cloud service that instantly enables Test Automation to make your Continuous Delivery ready.
 
 For more information please check out https://testim.io and https://help.testim.io/docs
 

package/cli/onExit.js

@@ -1,16 +1,22 @@
 'use strict';
 
 const constants = require('../commons/constants');
-const utils = require('../utils');
 const { requireWithFallback } = require('../commons/requireWithFallback');
 const { isCi } = require('./isCiRun');
 const { writeStackTrace } = require('./writeStackTrace');
 const logger = require('../commons/logger').getLogger('process-handler');
 
+let exitCodeIgnoreFailingTests = false;
+
 function getExitCode(result) {
     if (result instanceof Error) {
         return 1;
     }
+
+    if (exitCodeIgnoreFailingTests) {
+        return 0;
+    }
+
     result = result || {};
     const hasFailedTests = Object.values(result).some(
         ({ runnerStatus, success, testStatus, status }) => {
@@ -32,9 +38,13 @@ function closeChromeDriverIfRunning() {
     try {
         const chromedriver = requireWithFallback('chromedriver');
         chromedriver.stop();
+    // eslint-disable-next-line no-empty
     } catch (err) { }
 }
 
+module.exports.ignoreFailingTestsInExitCode = function () {
+    exitCodeIgnoreFailingTests = true;
+};
 
 
 module.exports.onExit = async function onExit(exitValue) {
@@ -42,6 +52,7 @@ module.exports.onExit = async function onExit(exitValue) {
         if (!isCi) {
             writeStackTrace(exitValue);
         } else {
+            // eslint-disable-next-line no-console
             console.error(exitValue, exitValue && exitValue.stack);
         }
     }

package/cli.js

@@ -7,7 +7,7 @@ require('./bluebirdConfig.js');
 const options = require('./runOptions');
 const EventEmitter = require('events');
 const logger = require('./commons/logger').getLogger('cli-entry');
-const { onExit } = require('./cli/onExit');
+const { onExit, ignoreFailingTestsInExitCode } = require('./cli/onExit');
 const testRunner = require('./runner');
 const prepareRunner = require('./commons/prepareRunner');
 const { CLI_MODE } = require('./commons/constants');
@@ -92,6 +92,10 @@ function main() {
                 options.localRCASaver = `http://localhost:${port}`;
             }
 
+            if (options.exitCodeIgnoreFailingTests) {
+                ignoreFailingTestsInExitCode();
+            }
+
             perf.log('right before testRunner.init/prepareRunner.prepare');
             return Promise.all([
                 testRunner.init(options),

package/commons/constants.js

@@ -33,29 +33,6 @@ module.exports = {
     test: {
         HIDDEN_PARAM: 'TST_HIDDEN_PARAM',
     },
-    deviceFarm: {
-        status: {
-            INITIALIZING: 'INITIALIZING',
-            PENDING: 'PENDING',
-            PENDING_CONCURRENCY: 'PENDING_CONCURRENCY',
-            PENDING_DEVICE: 'PENDING_DEVICE',
-            PROCESSING: 'PROCESSING',
-            SCHEDULING: 'SCHEDULING',
-            PREPARING: 'PREPARING',
-            RUNNING: 'RUNNING',
-            COMPLETED: 'COMPLETED',
-            STOPPING: 'STOPPING',
-        },
-        result: {
-            PENDING: 'PENDING',
-            PASSED: 'PASSED',
-            WARNED: 'WARNED',
-            FAILED: 'FAILED',
-            SKIPPED: 'SKIPPED',
-            ERRORED: 'ERRORED',
-            STOPPED: 'STOPPED',
-        },
-    },
     socketEventTypes: {
         TEST_RESULT_CREATED: 'test-result-created',
         TEST_RESULT_UPDATED: 'test-result-updated',
@@ -64,8 +41,6 @@ module.exports = {
     CLI_MODE: {
         EXTENSION: 'extension',
         SELENIUM: 'selenium',
-        APPIUM: 'appium',
-        DEVICE_FARM_APPIUM: 'device-farm-appium',
     },
     sessionType: {
         CODELESS: 'codeless',

package/commons/featureFlags.js

@@ -52,6 +52,8 @@ class FeatureFlagsService {
             autoSaveDownloadFileFireFox: new Rox.Flag(true),
             safariSelectOptionDispatchEventOnSelectElement: new Rox.Flag(true),
             experimentalPreCodeCompilation: new Rox.Flag(false),
+            /** Enables using top level await inside custom actions for non-IE browsers */
+            experimentalAsyncCustomCode: new Rox.Flag(),
             useSameBrowserForMultiTests: new LabFeatureFlag('labs'),
             highSpeedMode: new LabFeatureFlag(),
             usePortedHtml5DragDrop: new Rox.Flag(),

package/commons/npmWrapper.js

@@ -9,7 +9,7 @@ const Promise = require('bluebird');
 const fse = require('fs-extra');
 const logger = require('./logger').getLogger('cli-service');
 const { requireWithFallback } = require('./requireWithFallback');
-const os = require('os');
+const fs = require('fs');
 
 async function getLatestPackageVersion(packageName) {
     const result = await exec(`npm view ${packageName} version`);
@@ -40,6 +40,16 @@ function getLocallyInstalledPackageVersion(rootPath, packageName) {
     return require(path.join(rootPath, `./node_modules/${packageName}/package.json`)).version;
 }
 
+// this is not exactly correct, but it's good enough.
+async function fileExists(path) {
+    try {
+        await fs.promises.access(path);
+        return true;
+    } catch (err) {
+        return false;
+    }
+}
+
 async function installPackageLocally(rootPath, packageName, execOptions) {
     function getPathWithMissingPermissions(error) {
         const pathRegex = /EACCES[^']+'(.+)'/;
@@ -50,26 +60,48 @@ async function installPackageLocally(rootPath, packageName, execOptions) {
         return regexResult[1];
     }
 
-    return exec(`npm i ${packageName} --no-save --no-package-lock --no-prune --prefer-offline --no-audit --progress=false`, { ...execOptions, cwd: rootPath }).catch(err => {
-        const pathWithMissingPermissions = getPathWithMissingPermissions(err);
-        if (pathWithMissingPermissions) {
-            logger.info('Failed to install package due to insufficient write access', {
-                ...additionalLogDetails(),
-                package: packageName,
-                path: pathWithMissingPermissions,
-            });
-            // eslint-disable-next-line no-console
-            console.error(`
+    // this is here because our shrinkwrap blocks our lazy deps for some reason
+    const oldShrinkwrap = path.join(rootPath, 'npm-shrinkwrap.json');
+    const newShrinkwrap = path.join(rootPath, 'npm-shrinkwrap-dummy.json');
+    let renamed = false;
+    try {
+        try {
+            if (await fileExists(oldShrinkwrap)) {
+                await fs.promises.rename(oldShrinkwrap, newShrinkwrap);
+                renamed = true;
+            }
+        } catch (err) {
+            // ignore error
+        }
+        return await exec(`npm i ${packageName} --no-save --no-package-lock --no-prune --prefer-offline --no-audit --progress=false`, { ...execOptions, cwd: rootPath }).catch(err => {
+            const pathWithMissingPermissions = getPathWithMissingPermissions(err);
+            if (pathWithMissingPermissions) {
+                logger.info('Failed to install package due to insufficient write access', {
+                    ...additionalLogDetails(),
+                    package: packageName,
+                    path: pathWithMissingPermissions,
+                });
+                // eslint-disable-next-line no-console
+                console.error(`
 
 Testim failed installing the package ${packageName} due to insufficient permissions.
 This is probably due to an installation of @testim/testim-cli with sudo, and running it without sudo.
 Testim had missing write access to ${pathWithMissingPermissions}
 
 `);
-            throw new NpmPermissionsError(pathWithMissingPermissions);
+                throw new NpmPermissionsError(pathWithMissingPermissions);
+            }
+            throw err;
+        });
+    } finally {
+        if (renamed) {
+            try {
+                await fs.promises.rename(newShrinkwrap, oldShrinkwrap);
+            } catch (err) {
+                // ignore error
+            }
         }
-        throw err;
-    });
+    }
 }
 
 const localNpmLocation = path.resolve(require.resolve('npm'), '../../bin/npm-cli.js');

package/commons/npmWrapper.test.js

@@ -5,8 +5,8 @@ const { sinon, expect } = require('../../test/utils/testUtils');
 const os = require('os');
 const { NpmPermissionsError } = require('../errors');
 const path = require('path');
+
 const fs = require('fs');
-const { getCliLocation } = require('../utils');
 
 describe('npmWrapper', () => {
     describe('installPackageLocally', () => {
@@ -22,17 +22,22 @@ describe('npmWrapper', () => {
 
             let fakeChildProcess;
             let fakeLogger;
-
+            let fakeFS;
             let originalConsole;
             beforeEach(() => {
                 fakeChildProcess = { exec: sinon.stub() };
                 fakeLogger = { warn: sinon.stub(), info: sinon.stub() };
-
+                fakeFS = {
+                    promises: {
+                        access: sinon.stub().rejects(new Error()),
+                    },
+                };
                 originalConsole = global.console;
                 global.console = { log: sinon.stub(), error: sinon.stub() };
 
                 npmWrapper = proxyquire('./npmWrapper', {
                     child_process: fakeChildProcess,
+                    fs: fakeFS,
                     './logger': { getLogger: () => fakeLogger },
                 });
             });
@@ -65,7 +70,7 @@ describe('npmWrapper', () => {
 
                 stubExecRejection(execErr);
 
-                expect(npmWrapper.installPackageLocally('/some/dir', 'some-package')).to.be.rejectedWith(execErr);
+                await expect(npmWrapper.installPackageLocally('/some/dir', 'some-package')).to.be.rejectedWith(execErr);
             });
 
             it('should throw an error if an error which isnt related to permissions occurred', async () => {
@@ -73,7 +78,7 @@ describe('npmWrapper', () => {
 
                 stubExecRejection(execErr);
 
-                expect(npmWrapper.installPackageLocally('/some/dir', 'some-package')).to.be.rejectedWith(execErr);
+                await expect(npmWrapper.installPackageLocally('/some/dir', 'some-package')).to.be.rejectedWith(execErr);
             });
 
             it('should throw an error if stderr includes "EACCES", but the path was not specified', async () => {
@@ -81,7 +86,7 @@ describe('npmWrapper', () => {
 
                 stubExecRejection(execErr);
 
-                expect(npmWrapper.installPackageLocally('/some/dir', 'some-package')).to.be.rejectedWith(execErr);
+                await expect(npmWrapper.installPackageLocally('/some/dir', 'some-package')).to.be.rejectedWith(execErr);
             });
 
             [
@@ -194,5 +199,176 @@ Testim had missing write access to ${expectedPath}
                 expect(fs.existsSync(unexpectedDir), 'expected the package not to be installed - this could be a problem with the test itself, and not the tested class').to.be.false;
             }).timeout(20000);
         });
+
+        describe('shirnkwrap handling', () => {
+            let fakeChildProcess;
+            let fakeLogger;
+            let originalConsole;
+            const shrinkwrapPath = '/some/dir/npm-shrinkwrap.json';
+            const shrinkwrapDummyPath = '/some/dir/npm-shrinkwrap-dummy.json';
+            beforeEach(() => {
+                fakeChildProcess = { exec: sinon.stub() };
+                fakeLogger = { warn: sinon.stub(), info: sinon.stub() };
+                originalConsole = global.console;
+                global.console = { log: sinon.stub(), error: sinon.stub() };
+            });
+
+            afterEach(() => {
+                global.console = originalConsole;
+            });
+
+            it('does not call rename if access fails', async () => {
+                const fakeFS = {
+                    promises: {
+                        access: sinon.stub(),
+                        rename: sinon.stub(),
+                    },
+                };
+                fakeFS.promises.access.rejects();
+                const npmWrapper = proxyquire('./npmWrapper', {
+                    child_process: fakeChildProcess,
+                    fs: fakeFS,
+                    './logger': { getLogger: () => fakeLogger },
+                });
+
+                fakeChildProcess.exec.yields(undefined, []); //resolve without errors
+                const cwd = '/some/dir';
+                const pkg = 'some-package';
+                await npmWrapper.installPackageLocally(cwd, pkg);
+                sinon.assert.calledOnce(fakeFS.promises.access);
+                sinon.assert.notCalled(fakeFS.promises.rename);
+                expect(fakeFS.promises.access.getCall(0).args[0]).to.be.equal(shrinkwrapPath);
+            });
+
+            it('calls rename once if rename fails on the first time', async () => {
+                const fakeFS = {
+                    promises: {
+                        access: sinon.stub().resolves(),
+                        rename: sinon.stub().rejects(),
+                    },
+                };
+
+                const npmWrapper = proxyquire('./npmWrapper', {
+                    child_process: fakeChildProcess,
+                    fs: fakeFS,
+                    './logger': { getLogger: () => fakeLogger },
+                });
+
+                fakeChildProcess.exec.yields(undefined, []); //resolve without errors
+                const cwd = '/some/dir';
+                const pkg = 'some-package';
+                await npmWrapper.installPackageLocally(cwd, pkg);
+                sinon.assert.calledOnce(fakeFS.promises.access);
+                sinon.assert.calledOnce(fakeFS.promises.rename);
+            });
+
+            it('calls rename twice if first is success', async () => {
+                const fakeFS = {
+                    promises: {
+                        access: sinon.stub().resolves(),
+                        rename: sinon.stub().resolves(),
+                    },
+                };
+                const npmWrapper = proxyquire('./npmWrapper', {
+                    child_process: fakeChildProcess,
+                    fs: fakeFS,
+                    './logger': { getLogger: () => fakeLogger },
+                });
+
+                fakeChildProcess.exec.yields(undefined, []); //resolve without errors
+                const cwd = '/some/dir';
+                const pkg = 'some-package';
+
+                await npmWrapper.installPackageLocally(cwd, pkg);
+                sinon.assert.calledOnce(fakeFS.promises.access);
+                sinon.assert.calledTwice(fakeFS.promises.rename);
+                expect(fakeFS.promises.access.getCall(0).args[0]).to.be.equal(shrinkwrapPath);
+                expect(fakeFS.promises.rename.getCall(0).args[0]).to.be.equal(shrinkwrapPath);
+                expect(fakeFS.promises.rename.getCall(0).args[1]).to.be.equal(shrinkwrapDummyPath);
+                expect(fakeFS.promises.rename.getCall(1).args[0]).to.be.equal(shrinkwrapDummyPath);
+                expect(fakeFS.promises.rename.getCall(1).args[1]).to.be.equal(shrinkwrapPath);
+            });
+
+            it('doesn\'t throw if first rename fails', async () => {
+                const fakeFS = {
+                    promises: {
+                        access: sinon.stub().resolves(true),
+                        rename: sinon.stub().rejects(),
+                    },
+                };
+                const npmWrapper = proxyquire('./npmWrapper', {
+                    child_process: fakeChildProcess,
+                    fs: fakeFS,
+                    './logger': { getLogger: () => fakeLogger },
+                });
+
+                fakeChildProcess.exec.yields(undefined, []); //resolve without errors
+                const cwd = '/some/dir';
+                const pkg = 'some-package';
+                await npmWrapper.installPackageLocally(cwd, pkg);
+                sinon.assert.calledOnce(fakeFS.promises.access);
+                sinon.assert.calledOnce(fakeFS.promises.rename);
+                expect(fakeFS.promises.access.getCall(0).args[0]).to.be.equal(shrinkwrapPath);
+                expect(fakeFS.promises.rename.getCall(0).args[0]).to.be.equal(shrinkwrapPath);
+                expect(fakeFS.promises.rename.getCall(0).args[1]).to.be.equal(shrinkwrapDummyPath);
+            });
+
+            it('doesn\'t throw is second rename fails', async () => {
+                const fakeFS = {
+                    promises: {
+                        access: sinon.stub().resolves(),
+                        rename: sinon.stub().onFirstCall().resolves().onSecondCall()
+                            .rejects(),
+                    },
+                };
+
+                const npmWrapper = proxyquire('./npmWrapper', {
+                    child_process: fakeChildProcess,
+                    fs: fakeFS,
+                    './logger': { getLogger: () => fakeLogger },
+                });
+
+                fakeChildProcess.exec.yields(undefined, []); //resolve without errors
+                const cwd = '/some/dir';
+                const pkg = 'some-package';
+                await npmWrapper.installPackageLocally(cwd, pkg);
+                sinon.assert.calledOnce(fakeFS.promises.access);
+                sinon.assert.calledTwice(fakeFS.promises.rename);
+                expect(fakeFS.promises.access.getCall(0).args[0]).to.be.equal(shrinkwrapPath);
+                expect(fakeFS.promises.rename.getCall(0).args[0]).to.be.equal(shrinkwrapPath);
+                expect(fakeFS.promises.rename.getCall(0).args[1]).to.be.equal(shrinkwrapDummyPath);
+                expect(fakeFS.promises.rename.getCall(1).args[0]).to.be.equal(shrinkwrapDummyPath);
+                expect(fakeFS.promises.rename.getCall(1).args[1]).to.be.equal(shrinkwrapPath);
+            });
+
+            it('calls rename even if exec fails', async () => {
+                const fakeFS = {
+                    promises: {
+                        access: sinon.stub().resolves(),
+                        rename: sinon.stub().onFirstCall().resolves().onSecondCall()
+                            .rejects(),
+                    },
+                };
+
+                fakeChildProcess.exec.throws();
+
+                const npmWrapper = proxyquire('./npmWrapper', {
+                    child_process: fakeChildProcess,
+                    fs: fakeFS,
+                    './logger': { getLogger: () => fakeLogger },
+                });
+
+                const cwd = '/some/dir';
+                const pkg = 'some-package';
+                await expect(npmWrapper.installPackageLocally(cwd, pkg)).to.be.rejected;
+                sinon.assert.calledOnce(fakeFS.promises.access);
+                sinon.assert.calledTwice(fakeFS.promises.rename);
+                expect(fakeFS.promises.access.getCall(0).args[0]).to.be.equal(shrinkwrapPath);
+                expect(fakeFS.promises.rename.getCall(0).args[0]).to.be.equal(shrinkwrapPath);
+                expect(fakeFS.promises.rename.getCall(0).args[1]).to.be.equal(shrinkwrapDummyPath);
+                expect(fakeFS.promises.rename.getCall(1).args[0]).to.be.equal(shrinkwrapDummyPath);
+                expect(fakeFS.promises.rename.getCall(1).args[1]).to.be.equal(shrinkwrapPath);
+            });
+        });
     });
 });

package/commons/socket/testResultService.js

@@ -2,11 +2,9 @@ const testResultServiceSocketIO = require('./testResultServiceSocketIO');
 const socketService = require('./socketService');
 
 const { EventEmitter } = require('events');
-
-const testimServicesApi = require('../testimServicesApi');
 const featureFlags = require('../featureFlags');
 
-const {socketEventTypes} = require('../constants');
+const { socketEventTypes } = require('../constants');
 const Promise = require('bluebird');
 
 class TestResultService extends EventEmitter {
@@ -22,9 +20,9 @@ class TestResultService extends EventEmitter {
     joinToTestResult(resultId, testId) {
         //TODO - Consider unifying the joinToTestResult and listenToTestResult flows
         if (featureFlags.flags.useNewWSCLI.isEnabled()) {
-            return socketService.addFilter(`${resultId}:testResult`, {resultId, testId}, [
+            return socketService.addFilter(`${resultId}:testResult`, { resultId, testId }, [
                 socketEventTypes.TEST_RESULT_UPDATED,
-                socketEventTypes.TEST_RESULT_CREATED
+                socketEventTypes.TEST_RESULT_CREATED,
             ]);
         }
         testResultServiceSocketIO.joinRoom(resultId, testId);
@@ -54,17 +52,9 @@ class TestResultService extends EventEmitter {
         testResultServiceSocketIO.listenToTestResult(resultId, testId, onTestResultStatus);
     }
 
-    clearTestResult(projectId, resultId, testId, testResult) {
-        return testimServicesApi.clearTestResult(projectId, resultId, testId, testResult);
-    }
-
-    updateTestResult(projectId, resultId, testId, testResult, remoteRunId) {
-        return testimServicesApi.updateTestResult(projectId, resultId, testId, testResult, remoteRunId);
-    }
-
     getSocket() {
         if (featureFlags.flags.useNewWSCLI.isEnabled()) {
-            return;
+            return undefined;
         }
         return testResultServiceSocketIO.getSocket();
     }

package/commons/testimAnalytics.js

@@ -5,7 +5,6 @@ const config = require('./config');
 const Analytics = require('analytics-node');
 
 const analytics = new Analytics('sJOSIGKa5x5rJEGsaOlCjrgozAf7FnVY', { flushAt: 1 });
-const testimCustomToken = require('./testimCustomToken');
 
 function identify(data) {
     if (config.IS_ON_PREM) {

package/commons/testimDesiredCapabilitiesBuilder.js

@@ -9,7 +9,6 @@ const featureFlags = require('./featureFlags');
 const { CLI_MODE, mobileWeb, gridTypes } = require('./constants');
 const config = require('./config');
 const utils = require('../utils');
-const { getAppCaps } = require('./apkUploader/apkUploaderFactory');
 const LambdatestService = require('../services/lambdatestService');
 const logger = require('./logger').getLogger('testim-desired-capabilities-builder');
 
@@ -577,99 +576,6 @@ function buildSeleniumOptions(browserOptions, testName, testRunConfig, gridInfo,
     return opts;
 }
 
-function buildTestObject(browserOptions, testName, appCaps) {
-    if (!_.isEmpty(browserOptions.testobjectSauce)) {
-        return Object.assign({
-            idleTimeout: 30,
-            testobject_test_name: testName,
-            testobject_session_creation_timeout: String(browserOptions.browserTimeout),
-            deviceName: null,
-        }, appCaps, browserOptions.testobjectSauce);
-    }
-    return {};
-}
-
-function buildSaucelabsMobile(browserOptions, testName, appCaps) {
-    if (!_.isEmpty(browserOptions.saucelabs)) {
-        return Object.assign({
-            deviceName: null,
-            name: testName,
-            idleTimeout: 30,
-            browserName: '',
-        }, appCaps, browserOptions.saucelabs);
-    }
-    return {};
-}
-
-function buildAppiumOptions(browserOptions, gridInfo, nativeAppData, testName) {
-    const { getSessionTimeout, getSessionRetries, driverRequestTimeout, driverRequestRetries } = browserOptions;
-    const opts = {
-        host: gridInfo.host,
-        port: gridInfo.port || 4444,
-        path: gridInfo.path || '/wd/hub',
-        protocol: gridInfo.protocol || 'http',
-        logLevel: LOG_LEVEL,
-        connectionRetryTimeout: driverRequestTimeout,
-        connectionRetryCount: driverRequestRetries,
-        getSessionTimeout,
-        getSessionRetries,
-        desiredCapabilities: {
-            browserName: '',
-            noReset: false,
-            fullReset: false,
-        },
-    };
-
-    if (browserOptions.projectData.type === 'android') {
-        Object.assign(opts.desiredCapabilities, {
-            appPackage: nativeAppData.packageName,
-            appActivity: nativeAppData.activity,
-            platformName: 'Android',
-            automationName: 'uiautomator2',
-            autoLaunch: false,
-            ignoreUnimportantViews: false,
-            disableWindowAnimation: browserOptions.disableWindowAnimation,
-        });
-    } else if (browserOptions.projectData.type === 'ios') {
-        Object.assign(opts.desiredCapabilities, {
-            bundleId: nativeAppData.packageName,
-            platformName: 'iOS',
-            automationName: 'XCUITest',
-        });
-    }
-
-    if (browserOptions.deviceUdid) {
-        opts.desiredCapabilities.udid = browserOptions.deviceUdid;
-    }
-
-    if (browserOptions.deviceName) {
-        opts.desiredCapabilities.deviceName = browserOptions.deviceName;
-    }
-
-    if (gridInfo.user && gridInfo.key && gridInfo.type === 'saucelabs') {
-        browserOptions.saucelabs = browserOptions.saucelabs || {};
-        browserOptions.saucelabs.username = browserOptions.saucelabs.username || gridInfo.user;
-        browserOptions.saucelabs.accessKey = browserOptions.saucelabs.accessKey || gridInfo.key;
-    } else if (gridInfo.key && gridInfo.type === 'testobject') {
-        browserOptions.testobjectSauce = browserOptions.testobjectSauce || {};
-        browserOptions.testobjectSauce.testobjectApiKey = browserOptions.testobjectSauce.testobjectApiKey || gridInfo.key;
-    } else if (gridInfo.key && gridInfo.type === 'perfecto') {
-        browserOptions.perfecto = browserOptions.perfecto || {};
-        browserOptions.perfecto.securityToken = gridInfo.key;
-    }
-
-    const appCaps = getAppCaps(gridInfo);
-
-    Object.assign(
-        opts.desiredCapabilities,
-        buildTestObject(browserOptions, testName, appCaps),
-        buildSaucelabsMobile(browserOptions, testName, appCaps)
-    );
-
-    return opts;
-}
-
 module.exports = {
     buildSeleniumOptions,
-    buildAppiumOptions,
 };