@wdio/sauce-service 7.17.0 → 7.17.3

package/build/constants.d.ts

@@ -0,0 +1,3 @@
+import type { SauceServiceConfig } from './types';
+export declare const DEFAULT_OPTIONS: Partial<SauceServiceConfig>;
+//# sourceMappingURL=constants.d.ts.map

package/build/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAA;AAEjD,eAAO,MAAM,eAAe,EAAE,OAAO,CAAC,kBAAkB,CAEvD,CAAA"}

package/build/constants.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_OPTIONS = void 0;
+exports.DEFAULT_OPTIONS = {
+    uploadLogs: true
+};

package/build/index.d.ts

@@ -0,0 +1,13 @@
+import SauceLauncher from './launcher';
+import SauceService from './service';
+import { SauceServiceConfig } from './types';
+export default SauceService;
+export declare const launcher: typeof SauceLauncher;
+export * from './types';
+declare global {
+    namespace WebdriverIO {
+        interface ServiceOption extends SauceServiceConfig {
+        }
+    }
+}
+//# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,aAAa,MAAM,YAAY,CAAA;AACtC,OAAO,YAAY,MAAM,WAAW,CAAA;AACpC,OAAO,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAA;AAE5C,eAAe,YAAY,CAAA;AAC3B,eAAO,MAAM,QAAQ,sBAAgB,CAAA;AACrC,cAAc,SAAS,CAAA;AAEvB,OAAO,CAAC,MAAM,CAAC;IACX,UAAU,WAAW,CAAC;QAClB,UAAU,aAAc,SAAQ,kBAAkB;SAAG;KACxD;CACJ"}

package/build/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.launcher = void 0;
+const launcher_1 = __importDefault(require("./launcher"));
+const service_1 = __importDefault(require("./service"));
+exports.default = service_1.default;
+exports.launcher = launcher_1.default;
+__exportStar(require("./types"), exports);

package/build/launcher.d.ts

@@ -0,0 +1,21 @@
+import { SauceConnectOptions, SauceConnectInstance } from 'saucelabs';
+import type { Services, Capabilities, Options } from '@wdio/types';
+import type { SauceServiceConfig } from './types';
+export default class SauceLauncher implements Services.ServiceInstance {
+    private _options;
+    private _capabilities;
+    private _config;
+    private _api;
+    private _sauceConnectProcess?;
+    constructor(_options: SauceServiceConfig, _capabilities: unknown, _config: Options.Testrunner);
+    /**
+     * modify config and launch sauce connect
+     */
+    onPrepare(config: Options.Testrunner, capabilities: Capabilities.RemoteCapabilities): Promise<void>;
+    startTunnel(sauceConnectOpts: SauceConnectOptions, retryCount?: number): Promise<SauceConnectInstance>;
+    /**
+     * shut down sauce connect
+     */
+    onComplete(): Promise<undefined> | undefined;
+}
+//# sourceMappingURL=launcher.d.ts.map

package/build/launcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"launcher.d.ts","sourceRoot":"","sources":["../src/launcher.ts"],"names":[],"mappings":"AACA,OAAkB,EAAoB,mBAAmB,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAA;AAGlG,OAAO,KAAK,EAAE,QAAQ,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,aAAa,CAAA;AAGlE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAA;AAUjD,MAAM,CAAC,OAAO,OAAO,aAAc,YAAW,QAAQ,CAAC,eAAe;IAK9D,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,aAAa;IACrB,OAAO,CAAC,OAAO;IANnB,OAAO,CAAC,IAAI,CAAW;IACvB,OAAO,CAAC,oBAAoB,CAAC,CAAsB;gBAGvC,QAAQ,EAAE,kBAAkB,EAC5B,aAAa,EAAE,OAAO,EACtB,OAAO,EAAE,OAAO,CAAC,UAAU;IAKvC;;OAEG;IACG,SAAS,CACX,MAAM,EAAE,OAAO,CAAC,UAAU,EAC1B,YAAY,EAAE,YAAY,CAAC,kBAAkB;IA4D3C,WAAW,CAAE,gBAAgB,EAAE,mBAAmB,EAAE,UAAU,SAAI,GAAG,OAAO,CAAC,oBAAoB,CAAC;IA4BxG;;OAEG;IACH,UAAU;CAOb"}

package/build/launcher.js

@@ -0,0 +1,115 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const perf_hooks_1 = require("perf_hooks");
+const saucelabs_1 = __importDefault(require("saucelabs"));
+const logger_1 = __importDefault(require("@wdio/logger"));
+const utils_1 = require("./utils");
+const SC_RELAY_DEPCRECATION_WARNING = [
+    'The "scRelay" option is depcrecated and will be removed',
+    'with the upcoming versions of @wdio/sauce-service. Please',
+    'remove the option as tests should work identically without it.'
+].join(' ');
+const MAX_SC_START_TRIALS = 3;
+const log = (0, logger_1.default)('@wdio/sauce-service');
+class SauceLauncher {
+    constructor(_options, _capabilities, _config) {
+        this._options = _options;
+        this._capabilities = _capabilities;
+        this._config = _config;
+        this._api = new saucelabs_1.default(this._config);
+    }
+    /**
+     * modify config and launch sauce connect
+     */
+    async onPrepare(config, capabilities) {
+        var _a;
+        if (!this._options.sauceConnect) {
+            return;
+        }
+        const sauceConnectTunnelIdentifier = (((_a = this._options.sauceConnectOpts) === null || _a === void 0 ? void 0 : _a.tunnelIdentifier) ||
+            /**
+             * generate random identifier if not provided
+             */
+            `SC-tunnel-${Math.random().toString().slice(2)}`);
+        const sauceConnectOpts = {
+            noAutodetect: true,
+            tunnelIdentifier: sauceConnectTunnelIdentifier,
+            ...this._options.sauceConnectOpts
+        };
+        let endpointConfigurations = {};
+        if (this._options.scRelay) {
+            log.warn(SC_RELAY_DEPCRECATION_WARNING);
+            const scRelayPort = sauceConnectOpts.sePort || 4445;
+            sauceConnectOpts.sePort = scRelayPort;
+            endpointConfigurations = {
+                protocol: 'http',
+                hostname: 'localhost',
+                port: scRelayPort
+            };
+        }
+        const prepareCapability = (0, utils_1.makeCapabilityFactory)(sauceConnectTunnelIdentifier, endpointConfigurations);
+        if (Array.isArray(capabilities)) {
+            for (const capability of capabilities) {
+                prepareCapability(capability);
+            }
+        }
+        else {
+            for (const browserName of Object.keys(capabilities)) {
+                const caps = capabilities[browserName].capabilities;
+                prepareCapability(caps.alwaysMatch || caps);
+            }
+        }
+        /**
+         * measure SC boot time
+         */
+        const obs = new perf_hooks_1.PerformanceObserver((list) => {
+            const entry = list.getEntries()[0];
+            log.info(`Sauce Connect successfully started after ${entry.duration}ms`);
+        });
+        obs.observe({ entryTypes: ['measure'] });
+        perf_hooks_1.performance.mark('sauceConnectStart');
+        this._sauceConnectProcess = await this.startTunnel(sauceConnectOpts);
+        perf_hooks_1.performance.mark('sauceConnectEnd');
+        perf_hooks_1.performance.measure('bootTime', 'sauceConnectStart', 'sauceConnectEnd');
+    }
+    async startTunnel(sauceConnectOpts, retryCount = 0) {
+        try {
+            const scProcess = await this._api.startSauceConnect(sauceConnectOpts);
+            return scProcess;
+        }
+        catch (err) {
+            ++retryCount;
+            /**
+             * fail starting Sauce Connect eventually
+             */
+            if (
+            /**
+             * only fail for ENOENT errors due to racing condition
+             * see: https://github.com/saucelabs/node-saucelabs/issues/86
+             */
+            !err.message.includes('ENOENT') ||
+                /**
+                 * or if we reached the maximum rety count
+                 */
+                retryCount >= MAX_SC_START_TRIALS) {
+                throw err;
+            }
+            log.debug(`Failed to start Sauce Connect Proxy due to ${err.stack}`);
+            log.debug(`Retrying ${retryCount}/${MAX_SC_START_TRIALS}`);
+            return this.startTunnel(sauceConnectOpts, retryCount);
+        }
+    }
+    /**
+     * shut down sauce connect
+     */
+    onComplete() {
+        if (!this._sauceConnectProcess) {
+            return;
+        }
+        return this._sauceConnectProcess.close();
+    }
+}
+exports.default = SauceLauncher;

package/build/service.d.ts

@@ -0,0 +1,70 @@
+import { Job } from 'saucelabs';
+import type { Services, Capabilities, Options, Frameworks } from '@wdio/types';
+import type { Browser, MultiRemoteBrowser } from 'webdriverio';
+import { SauceServiceConfig } from './types';
+export default class SauceService implements Services.ServiceInstance {
+    private _capabilities;
+    private _config;
+    private _testCnt;
+    private _maxErrorStackLength;
+    private _failures;
+    private _isServiceEnabled;
+    private _isJobNameSet;
+    private _options;
+    private _api;
+    private _browser?;
+    private _isRDC?;
+    private _suiteTitle?;
+    private _cid;
+    constructor(options: SauceServiceConfig, _capabilities: Capabilities.RemoteCapability, _config: Options.Testrunner);
+    /**
+     * gather information about runner
+     */
+    beforeSession(_: never, __: never, ___: never, cid: string): void;
+    before(caps: unknown, specs: string[], browser: Browser<'async'> | MultiRemoteBrowser<'async'>): void;
+    beforeSuite(suite: Frameworks.Suite): Promise<void>;
+    beforeTest(test: Frameworks.Test): Promise<unknown>;
+    afterSuite(suite: Frameworks.Suite): void;
+    private _reportErrorLog;
+    afterTest(test: Frameworks.Test, context: unknown, results: Frameworks.TestResult): void;
+    afterHook(test: never, context: never, results: Frameworks.TestResult): void;
+    /**
+     * For CucumberJS
+     */
+    beforeFeature(uri: unknown, feature: {
+        name: string;
+    }): Promise<unknown>;
+    beforeScenario(world: Frameworks.World): Promise<unknown> | undefined;
+    beforeStep(step: Frameworks.PickleStep): Promise<unknown>;
+    /**
+     *
+     * Runs before a Cucumber Scenario.
+     * @param world world object containing information on pickle and test step
+     * @param result result object containing
+     * @param result.passed   true if scenario has passed
+     * @param result.error    error stack if scenario failed
+     * @param result.duration duration of scenario in milliseconds
+     */
+    afterScenario(world: Frameworks.World, result: Frameworks.PickleResult): void;
+    /**
+     * update Sauce Labs job
+     */
+    after(result: number): Promise<unknown>;
+    /**
+     * upload files to Sauce Labs platform
+     * @param jobId id of the job
+     * @returns a promise that is resolved once all files got uploaded
+     */
+    private _uploadLogs;
+    onReload(oldSessionId: string, newSessionId: string): Promise<void> | undefined;
+    updateJob(sessionId: string, failures: number, calledOnReload?: boolean, browserName?: string): Promise<void>;
+    /**
+     * VM message data
+     */
+    getBody(failures: number, calledOnReload?: boolean, browserName?: string): Partial<Job>;
+    /**
+     * Update the running Sauce Labs Job with an annotation
+     */
+    setAnnotation(annotation: string): Promise<unknown>;
+}
+//# sourceMappingURL=service.d.ts.map

package/build/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../src/service.ts"],"names":[],"mappings":"AAGA,OAAkB,EAAoB,GAAG,EAAE,MAAM,WAAW,CAAA;AAE5D,OAAO,KAAK,EAAE,QAAQ,EAAE,YAAY,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAC9E,OAAO,KAAK,EAAE,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAG9D,OAAO,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAA;AAO5C,MAAM,CAAC,OAAO,OAAO,YAAa,YAAW,QAAQ,CAAC,eAAe;IAgB7D,OAAO,CAAC,aAAa;IACrB,OAAO,CAAC,OAAO;IAhBnB,OAAO,CAAC,QAAQ,CAAI;IACpB,OAAO,CAAC,oBAAoB,CAAI;IAChC,OAAO,CAAC,SAAS,CAAI;IACrB,OAAO,CAAC,iBAAiB,CAAO;IAChC,OAAO,CAAC,aAAa,CAAQ;IAE7B,OAAO,CAAC,QAAQ,CAAoB;IACpC,OAAO,CAAC,IAAI,CAAW;IACvB,OAAO,CAAC,QAAQ,CAAC,CAAgD;IACjE,OAAO,CAAC,MAAM,CAAC,CAAS;IACxB,OAAO,CAAC,WAAW,CAAC,CAAQ;IAC5B,OAAO,CAAC,IAAI,CAAK;gBAGb,OAAO,EAAE,kBAAkB,EACnB,aAAa,EAAE,YAAY,CAAC,gBAAgB,EAC5C,OAAO,EAAE,OAAO,CAAC,UAAU;IAOvC;;OAEG;IACH,aAAa,CAAE,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM;IAkB3D,MAAM,CAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,GAAG,kBAAkB,CAAC,OAAO,CAAC;IAazF,WAAW,CAAE,KAAK,EAAE,UAAU,CAAC,KAAK;IAepC,UAAU,CAAE,IAAI,EAAE,UAAU,CAAC,IAAI;IAqDvC,UAAU,CAAE,KAAK,EAAE,UAAU,CAAC,KAAK;IAMnC,OAAO,CAAC,eAAe;IAKvB,SAAS,CAAE,IAAI,EAAE,UAAU,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,UAAU,CAAC,UAAU;IAyClF,SAAS,CAAE,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,UAAU,CAAC,UAAU;IAetE;;OAEG;IACG,aAAa,CAAE,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE;IAuB5D,cAAc,CAAE,KAAK,EAAE,UAAU,CAAC,KAAK;IAajC,UAAU,CAAE,IAAI,EAAE,UAAU,CAAC,UAAU;IAY7C;;;;;;;;OAQG;IACH,aAAa,CAAC,KAAK,EAAE,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,CAAC,YAAY;IAOtE;;OAEG;IACG,KAAK,CAAE,MAAM,EAAE,MAAM;IAsC3B;;;;OAIG;YACW,WAAW;IAezB,QAAQ,CAAE,YAAY,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM;IAmB9C,SAAS,CAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,cAAc,UAAQ,EAAE,WAAW,CAAC,EAAE,MAAM;IAMlG;;OAEG;IACH,OAAO,CAAE,QAAQ,EAAE,MAAM,EAAE,cAAc,UAAQ,EAAE,WAAW,CAAC,EAAE,MAAM;IAgDvE;;OAEG;IACG,aAAa,CAAE,UAAU,EAAE,MAAM;CAkB1C"}

package/build/service.js

@@ -0,0 +1,350 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const saucelabs_1 = __importDefault(require("saucelabs"));
+const logger_1 = __importDefault(require("@wdio/logger"));
+const utils_1 = require("./utils");
+const constants_1 = require("./constants");
+const jobDataProperties = ['name', 'tags', 'public', 'build', 'custom-data'];
+const log = (0, logger_1.default)('@wdio/sauce-service');
+class SauceService {
+    constructor(options, _capabilities, _config) {
+        this._capabilities = _capabilities;
+        this._config = _config;
+        this._testCnt = 0;
+        this._maxErrorStackLength = 5;
+        this._failures = 0; // counts failures between reloads
+        this._isServiceEnabled = true;
+        this._isJobNameSet = false;
+        this._cid = '';
+        this._options = { ...constants_1.DEFAULT_OPTIONS, ...options };
+        this._api = new saucelabs_1.default(this._config);
+        this._maxErrorStackLength = this._options.maxErrorStackLength || this._maxErrorStackLength;
+    }
+    /**
+     * gather information about runner
+     */
+    beforeSession(_, __, ___, cid) {
+        this._cid = cid;
+        /**
+         * if no user and key is specified even though a sauce service was
+         * provided set user and key with values so that the session request
+         * will fail
+         */
+        if (!this._config.user) {
+            this._isServiceEnabled = false;
+            this._config.user = 'unknown_user';
+        }
+        if (!this._config.key) {
+            this._isServiceEnabled = false;
+            this._config.key = 'unknown_key';
+        }
+    }
+    before(caps, specs, browser) {
+        this._browser = browser;
+        // Ensure capabilities are not null in case of multiremote
+        // Changed from `this._browser.capabilities` to this to get the correct
+        // capabilities for EMUSIM (with the postfix) to determine ff the string
+        // contains `simulator` or `emulator` it's an EMU/SIM session
+        // `this._browser.capabilities` returns the process data from Sauce which is without
+        // the postfix
+        const capabilities = this._browser.requestedCapabilities || {};
+        this._isRDC = (0, utils_1.isRDC)(capabilities);
+    }
+    async beforeSuite(suite) {
+        this._suiteTitle = suite.title;
+        /**
+         * Make sure we account for the cases where there is a long running `before` function for a
+         * suite or one that can fail so we set the default job name at the suite level
+         * Don't do this for Jasmine because the `suiteTitle` is `Jasmine__TopLevel__Suite` and the
+         * `fullName` is `null`, so no alternative
+         **/
+        if (this._browser && !this._isRDC && !this._isJobNameSet && this._suiteTitle !== 'Jasmine__TopLevel__Suite') {
+            await this.setAnnotation('sauce:job-name=' + this._suiteTitle);
+            this._isJobNameSet = true;
+        }
+    }
+    async beforeTest(test) {
+        if (!this._isServiceEnabled || !this._browser) {
+            return;
+        }
+        /**
+         * in jasmine we get Jasmine__TopLevel__Suite as title since service using test
+         * framework hooks in order to execute async functions.
+         * This tweak allows us to set the real suite name for jasmine jobs.
+         */
+        /* istanbul ignore if */
+        if (this._suiteTitle === 'Jasmine__TopLevel__Suite') {
+            this._suiteTitle = test.fullName.slice(0, test.fullName.indexOf(test.description || '') - 1);
+        }
+        if (this._browser && !this._isJobNameSet) {
+            let jobName = this._suiteTitle;
+            if (this._options.setJobName) {
+                jobName = this._options.setJobName(this._config, this._capabilities, this._suiteTitle);
+                await this.setAnnotation(`sauce:job-name=${jobName}`);
+                this._isJobNameSet = true;
+            }
+            if (!this._isJobNameSet) {
+                await this.setAnnotation(`sauce:job-name=${jobName}`);
+                this._isJobNameSet = true;
+            }
+        }
+        /**
+         * Date:    20200714
+         * Remark:  Sauce Unified Platform doesn't support updating the context yet.
+         */
+        if (this._isRDC) {
+            return;
+        }
+        const fullTitle = (
+        /**
+         * Jasmine
+         */
+        test.fullName ||
+            /**
+             * Mocha
+             */
+            `${test.parent} - ${test.title}`);
+        return this.setAnnotation(`sauce:context=${fullTitle}`);
+    }
+    afterSuite(suite) {
+        if (Object.prototype.hasOwnProperty.call(suite, 'error')) {
+            ++this._failures;
+        }
+    }
+    _reportErrorLog(error) {
+        const lines = (error.stack || '').split(/\r?\n/).slice(0, this._maxErrorStackLength);
+        lines.forEach((line) => this.setAnnotation(`sauce:context=${line.replace((0, utils_1.ansiRegex)(), '')}`));
+    }
+    afterTest(test, context, results) {
+        /**
+         * If the test failed push the stack to Sauce Labs in separate lines
+         * This should not be done for UP because it's not supported yet and
+         * should be removed when UP supports `sauce:context`
+         */
+        if (results.error && results.error.stack && !this._isRDC) {
+            this._reportErrorLog(results.error);
+        }
+        /**
+         * remove failure if test was retried and passed
+         * > Mocha only
+         */
+        if (test._retriedTest && results.passed) {
+            --this._failures;
+            return;
+        }
+        /**
+         * don't bump failure number if test was retried and still failed
+         * > Mocha only
+         */
+        if (test._retriedTest &&
+            !results.passed &&
+            (typeof test._currentRetry === 'number' &&
+                typeof test._retries === 'number' &&
+                test._currentRetry < test._retries)) {
+            return;
+        }
+        const isJasminePendingError = typeof results.error === 'string' && results.error.includes('marked Pending');
+        if (!results.passed && !isJasminePendingError) {
+            ++this._failures;
+        }
+    }
+    afterHook(test, context, results) {
+        /**
+         * If the test failed push the stack to Sauce Labs in separate lines
+         * This should not be done for UP because it's not supported yet and
+         * should be removed when UP supports `sauce:context`
+         */
+        if (results.error && !this._isRDC) {
+            this._reportErrorLog(results.error);
+        }
+        if (!results.passed) {
+            ++this._failures;
+        }
+    }
+    /**
+     * For CucumberJS
+     */
+    async beforeFeature(uri, feature) {
+        if (!this._isServiceEnabled || !this._browser) {
+            return;
+        }
+        this._suiteTitle = feature.name;
+        if (this._browser && !this._isJobNameSet) {
+            await this.setAnnotation(`sauce:job-name=${this._suiteTitle}`);
+            this._isJobNameSet = true;
+        }
+        /**
+         * Date:    20200714
+         * Remark:  Sauce Unified Platform doesn't support updating the context yet.
+         */
+        if (this._isRDC) {
+            return;
+        }
+        return this.setAnnotation(`sauce:context=Feature: ${this._suiteTitle}`);
+    }
+    beforeScenario(world) {
+        /**
+         * Date:    20200714
+         * Remark:  Sauce Unified Platform doesn't support updating the context yet.
+         */
+        if (!this._isServiceEnabled || this._isRDC || !this._browser) {
+            return;
+        }
+        const scenarioName = world.pickle.name || 'unknown scenario';
+        return this.setAnnotation(`sauce:context=-Scenario: ${scenarioName}`);
+    }
+    async beforeStep(step) {
+        /**
+         * Remark:  Sauce Unified Platform doesn't support updating the context yet.
+         */
+        if (!this._isServiceEnabled || this._isRDC || !this._browser) {
+            return;
+        }
+        const { keyword, text } = step;
+        return this.setAnnotation(`sauce:context=--Step: ${keyword}${text}`);
+    }
+    /**
+     *
+     * Runs before a Cucumber Scenario.
+     * @param world world object containing information on pickle and test step
+     * @param result result object containing
+     * @param result.passed   true if scenario has passed
+     * @param result.error    error stack if scenario failed
+     * @param result.duration duration of scenario in milliseconds
+     */
+    afterScenario(world, result) {
+        // check if scenario has failed
+        if (!result.passed) {
+            ++this._failures;
+        }
+    }
+    /**
+     * update Sauce Labs job
+     */
+    async after(result) {
+        if (!this._browser || !this._isServiceEnabled) {
+            return;
+        }
+        let failures = this._failures;
+        /**
+         * set failures if user has bail option set in which case afterTest and
+         * afterSuite aren't executed before after hook
+         */
+        if (this._config.mochaOpts && this._config.mochaOpts.bail && Boolean(result)) {
+            failures = 1;
+        }
+        const status = 'status: ' + (failures > 0 ? 'failing' : 'passing');
+        if (!this._browser.isMultiremote) {
+            await this._uploadLogs(this._browser.sessionId);
+            log.info(`Update job with sessionId ${this._browser.sessionId}, ${status}`);
+            return this._isRDC ?
+                this.setAnnotation(`sauce:job-result=${failures === 0}`) :
+                this.updateJob(this._browser.sessionId, failures);
+        }
+        const multiRemoteBrowser = this._browser;
+        return Promise.all(Object.keys(this._capabilities).map(async (browserName) => {
+            const isMultiRemoteRDC = (0, utils_1.isRDC)(multiRemoteBrowser[browserName].capabilities);
+            log.info(`Update multiRemote job for browser "${browserName}" and sessionId ${multiRemoteBrowser[browserName].sessionId}, ${status}`);
+            // Sauce Unified Platform (RDC) can not be updated with an API.
+            // The logs can also not be uploaded
+            if (isMultiRemoteRDC) {
+                return this.setAnnotation(`sauce:job-result=${failures === 0}`);
+            }
+            await this._uploadLogs(multiRemoteBrowser[browserName].sessionId);
+            return this.updateJob(multiRemoteBrowser[browserName].sessionId, failures, false, browserName);
+        }));
+    }
+    /**
+     * upload files to Sauce Labs platform
+     * @param jobId id of the job
+     * @returns a promise that is resolved once all files got uploaded
+     */
+    async _uploadLogs(jobId) {
+        if (!this._options.uploadLogs || !this._config.outputDir) {
+            return;
+        }
+        const files = (await fs_1.default.promises.readdir(this._config.outputDir))
+            .filter((file) => file.startsWith(`wdio-${this._cid}`) && file.endsWith('.log'));
+        log.info(`Uploading WebdriverIO logs (${files.join(', ')}) to Sauce Labs`);
+        return this._api.uploadJobAssets(jobId, { files: files.map((file) => path_1.default.join(this._config.outputDir, file)) }).catch((err) => log.error(`Couldn't upload log files to Sauce Labs: ${err.message}`));
+    }
+    onReload(oldSessionId, newSessionId) {
+        if (!this._browser || !this._isServiceEnabled) {
+            return;
+        }
+        const status = 'status: ' + (this._failures > 0 ? 'failing' : 'passing');
+        if (!this._browser.isMultiremote) {
+            log.info(`Update (reloaded) job with sessionId ${oldSessionId}, ${status}`);
+            return this.updateJob(oldSessionId, this._failures, true);
+        }
+        const mulitremoteBrowser = this._browser;
+        const browserName = mulitremoteBrowser.instances.filter((browserName) => mulitremoteBrowser[browserName].sessionId === newSessionId)[0];
+        log.info(`Update (reloaded) multiremote job for browser "${browserName}" and sessionId ${oldSessionId}, ${status}`);
+        return this.updateJob(oldSessionId, this._failures, true, browserName);
+    }
+    async updateJob(sessionId, failures, calledOnReload = false, browserName) {
+        const body = this.getBody(failures, calledOnReload, browserName);
+        await this._api.updateJob(this._config.user, sessionId, body);
+        this._failures = 0;
+    }
+    /**
+     * VM message data
+     */
+    getBody(failures, calledOnReload = false, browserName) {
+        let body = {};
+        /**
+         * add reload count to title if reload is used
+         */
+        if (calledOnReload || this._testCnt) {
+            /**
+             * set default values
+             */
+            body.name = this._suiteTitle;
+            if (browserName) {
+                body.name = `${browserName}: ${body.name}`;
+            }
+            let testCnt = ++this._testCnt;
+            const mulitremoteBrowser = this._browser;
+            if (this._browser && this._browser.isMultiremote) {
+                testCnt = Math.ceil(testCnt / mulitremoteBrowser.instances.length);
+            }
+            body.name += ` (${testCnt})`;
+        }
+        let caps = this._capabilities['sauce:options'] || this._capabilities;
+        for (let prop of jobDataProperties) {
+            if (!caps[prop]) {
+                continue;
+            }
+            body[prop] = caps[prop];
+        }
+        if (this._options.setJobName) {
+            body.name = this._options.setJobName(this._config, this._capabilities, this._suiteTitle);
+        }
+        body.passed = failures === 0;
+        return body;
+    }
+    /**
+     * Update the running Sauce Labs Job with an annotation
+     */
+    async setAnnotation(annotation) {
+        if (!this._browser) {
+            return;
+        }
+        if (this._browser.isMultiremote) {
+            const multiRemoteBrowser = this._browser;
+            return Promise.all(Object.keys(this._capabilities).map(async (browserName) => {
+                const isMultiRemoteRDC = (0, utils_1.isRDC)(multiRemoteBrowser[browserName].capabilities);
+                if ((isMultiRemoteRDC && !annotation.includes('sauce:context')) || !isMultiRemoteRDC) {
+                    return this._browser.execute(annotation);
+                }
+            }));
+        }
+        return this._browser.execute(annotation);
+    }
+}
+exports.default = SauceService;

package/build/types.d.ts

@@ -0,0 +1,46 @@
+import type { SauceConnectOptions } from 'saucelabs';
+import type { Capabilities, Options } from '@wdio/types';
+export interface SauceServiceConfig {
+    /**
+     * Specify the max error stack length represents the amount of error stack lines that will be
+     * pushed to Sauce Labs when a test fails
+     */
+    maxErrorStackLength?: number;
+    /**
+     * Specify tunnel identifier for Sauce Connect tunnel
+     */
+    tunnelIdentifier?: string;
+    /**
+     * Specify tunnel identifier for Sauce Connect parent tunnel
+     */
+    parentTunnel?: string;
+    /**
+     * If true it runs Sauce Connect and opens a secure connection between a Sauce Labs virtual
+     * machine running your browser tests.
+     *
+     * @default false
+     */
+    sauceConnect?: boolean;
+    /**
+     * Apply Sauce Connect options (e.g. to change port number or logFile settings). See this
+     * list for more information: https://github.com/bermi/sauce-connect-launcher#advanced-usage
+     *
+     * @default {}
+     */
+    sauceConnectOpts?: SauceConnectOptions;
+    /**
+     * Upload WebdriverIO logs to the Sauce Labs platform.
+     * @default true
+     */
+    uploadLogs?: boolean;
+    /**
+     * Use Sauce Connect as a Selenium Relay. See more [here](https://wiki.saucelabs.com/display/DOCS/Using+the+Selenium+Relay+with+Sauce+Connect+Proxy).
+     * @deprecated
+     */
+    scRelay?: boolean;
+    /**
+     * Dynamically control the name of the job
+     */
+    setJobName?: (config: Options.Testrunner, capabilities: Capabilities.RemoteCapability, suiteTitle: string) => string;
+}
+//# sourceMappingURL=types.d.ts.map

package/build/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAA;AACpD,OAAO,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,aAAa,CAAA;AAExD,MAAM,WAAW,kBAAkB;IAC/B;;;OAGG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAA;IAE5B;;OAEG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAA;IAEzB;;OAEG;IACH,YAAY,CAAC,EAAE,MAAM,CAAA;IAErB;;;;;OAKG;IACH,YAAY,CAAC,EAAE,OAAO,CAAA;IAEtB;;;;;OAKG;IACH,gBAAgB,CAAC,EAAE,mBAAmB,CAAA;IAEtC;;;OAGG;IACH,UAAU,CAAC,EAAE,OAAO,CAAA;IAEpB;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;IAEjB;;OAEG;IACH,UAAU,CAAC,EAAE,CACT,MAAM,EAAE,OAAO,CAAC,UAAU,EAC1B,YAAY,EAAE,YAAY,CAAC,gBAAgB,EAC3C,UAAU,EAAE,MAAM,KACjB,MAAM,CAAA;CACd"}

package/build/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/utils.d.ts

@@ -0,0 +1,58 @@
+import type { Capabilities } from '@wdio/types';
+/**
+ * Determine if the current instance is a RDC instance. RDC tests are Real Device tests
+ * that can be started with different sets of capabilities. A deviceName is not mandatory, the only mandatory cap for
+ * RDC is the platformName. Downside of the platformName is that is can also be EMUSIM. EMUSIM can be distinguished by
+ * the `Emulator|Simulator` postfix
+ *
+ * @param {object} caps
+ * @returns {boolean}
+ *
+ * This is what we get back from the UP (for now)
+ *
+ * capabilities =  {
+ *  webStorageEnabled: false,
+ *  locationContextEnabled: false,
+ *  browserName: 'safari',
+ *  platform: 'MAC',
+ *  javascriptEnabled: true,
+ *  databaseEnabled: false,
+ *  takesScreenshot: true,
+ *  networkConnectionEnabled: false,
+ *  platformVersion: '12.1.2',
+ *  webDriverAgentUrl: 'http://127.0.0.1:5700',
+ *  testobject_platform_name: 'iOS',
+ *  orientation: 'PORTRAIT',
+ *  realDevice: true,
+ *  build: 'Sauce Real Device browser iOS - 1594732389756',
+ *  commandTimeouts: { default: 60000 },
+ *  testobject_device: 'iPhone_XS_ws',
+ *  automationName: 'XCUITest',
+ *  platformName: 'iOS',
+ *  udid: '',
+ *  deviceName: '',
+ *  testobject_test_report_api_url: '',
+ *  testobject_test_report_url: '',
+ *  testobject_user_id: 'wim.selles',
+ *  testobject_project_id: 'saucelabs-default',
+ *  testobject_test_report_id: 51,
+ *  testobject_device_name: 'iPhone XS',
+ *  testobject_device_session_id: '',
+ *  deviceContextId: ''
+ * }
+ */
+export declare function isRDC(caps: Capabilities.DesiredCapabilities): boolean;
+/**
+ * Determine if this is an EMUSIM session
+ * @param {object} caps
+ * @returns {boolean}
+ */
+export declare function isEmuSim(caps: Capabilities.DesiredCapabilities): boolean;
+/** Ensure capabilities are in the correct format for Sauce Labs
+ * @param {string} tunnelIdentifier - The default Sauce Connect tunnel identifier
+ * @param {object} options - Additional options to set on the capability
+ * @returns {function(object): void} - A function that mutates a single capability
+ */
+export declare function makeCapabilityFactory(tunnelIdentifier: string, options: any): (capability: Capabilities.DesiredCapabilities) => void;
+export declare function ansiRegex(): RegExp;
+//# sourceMappingURL=utils.d.ts.map

package/build/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAI/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,wBAAgB,KAAK,CAAE,IAAI,EAAE,YAAY,CAAC,mBAAmB,WAM5D;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CAAE,IAAI,EAAE,YAAY,CAAC,mBAAmB,WAM/D;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,gBAAgB,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,gBACpD,aAAa,mBAAmB,UA2BvD;AAED,wBAAgB,SAAS,WAOxB"}

package/build/utils.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ansiRegex = exports.makeCapabilityFactory = exports.isEmuSim = exports.isRDC = void 0;
+/**
+ * Determine if the current instance is a RDC instance. RDC tests are Real Device tests
+ * that can be started with different sets of capabilities. A deviceName is not mandatory, the only mandatory cap for
+ * RDC is the platformName. Downside of the platformName is that is can also be EMUSIM. EMUSIM can be distinguished by
+ * the `Emulator|Simulator` postfix
+ *
+ * @param {object} caps
+ * @returns {boolean}
+ *
+ * This is what we get back from the UP (for now)
+ *
+ * capabilities =  {
+ *  webStorageEnabled: false,
+ *  locationContextEnabled: false,
+ *  browserName: 'safari',
+ *  platform: 'MAC',
+ *  javascriptEnabled: true,
+ *  databaseEnabled: false,
+ *  takesScreenshot: true,
+ *  networkConnectionEnabled: false,
+ *  platformVersion: '12.1.2',
+ *  webDriverAgentUrl: 'http://127.0.0.1:5700',
+ *  testobject_platform_name: 'iOS',
+ *  orientation: 'PORTRAIT',
+ *  realDevice: true,
+ *  build: 'Sauce Real Device browser iOS - 1594732389756',
+ *  commandTimeouts: { default: 60000 },
+ *  testobject_device: 'iPhone_XS_ws',
+ *  automationName: 'XCUITest',
+ *  platformName: 'iOS',
+ *  udid: '',
+ *  deviceName: '',
+ *  testobject_test_report_api_url: '',
+ *  testobject_test_report_url: '',
+ *  testobject_user_id: 'wim.selles',
+ *  testobject_project_id: 'saucelabs-default',
+ *  testobject_test_report_id: 51,
+ *  testobject_device_name: 'iPhone XS',
+ *  testobject_device_session_id: '',
+ *  deviceContextId: ''
+ * }
+ */
+function isRDC(caps) {
+    const { 'appium:deviceName': appiumDeviceName = '', deviceName = '', platformName = '' } = caps;
+    const name = appiumDeviceName || deviceName;
+    // If the string contains `simulator` or `emulator` it's an EMU/SIM session
+    return !name.match(/(simulator)|(emulator)/gi) && !!platformName.match(/(ios)|(android)/gi);
+}
+exports.isRDC = isRDC;
+/**
+ * Determine if this is an EMUSIM session
+ * @param {object} caps
+ * @returns {boolean}
+ */
+function isEmuSim(caps) {
+    const { 'appium:deviceName': appiumDeviceName = '', deviceName = '', platformName = '' } = caps;
+    const name = appiumDeviceName || deviceName;
+    // If the string contains `simulator` or `emulator` it's an EMU/SIM session
+    return !!name.match(/(simulator)|(emulator)/gi) && !!platformName.match(/(ios)|(android)/gi);
+}
+exports.isEmuSim = isEmuSim;
+/** Ensure capabilities are in the correct format for Sauce Labs
+ * @param {string} tunnelIdentifier - The default Sauce Connect tunnel identifier
+ * @param {object} options - Additional options to set on the capability
+ * @returns {function(object): void} - A function that mutates a single capability
+ */
+function makeCapabilityFactory(tunnelIdentifier, options) {
+    return (capability) => {
+        // Check if this is a 'valid' W3C request, this is done with a simple check
+        // where we assume that if only one cap has `:` it's W3C, even if the request
+        // is a mix of JWP and W3C. This is hard to check
+        const isW3CRequest = Boolean(Object.keys(capability).find((cap) => cap.includes(':')));
+        // If the `sauce:options` are not provided and it is a W3C session
+        // then add it
+        if (!capability['sauce:options'] && isW3CRequest) {
+            capability['sauce:options'] = {};
+        }
+        Object.assign(capability, options);
+        const sauceOptions = (isW3CRequest ? capability['sauce:options'] : capability);
+        sauceOptions.tunnelIdentifier = (capability.tunnelIdentifier ||
+            sauceOptions.tunnelIdentifier ||
+            tunnelIdentifier);
+        if (isW3CRequest) {
+            delete capability.tunnelIdentifier;
+        }
+    };
+}
+exports.makeCapabilityFactory = makeCapabilityFactory;
+function ansiRegex() {
+    const pattern = [
+        '[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:[a-zA-Z\\d]*(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)',
+        '(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))'
+    ].join('|');
+    return new RegExp(pattern, 'g');
+}
+exports.ansiRegex = ansiRegex;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wdio/sauce-service",
-  "version": "7.17.0",
+  "version": "7.17.3",
   "description": "WebdriverIO service that provides a better integration into Sauce Labs",
   "author": "Christian Bromann <christian@saucelabs.com>",
   "homepage": "https://github.com/webdriverio/webdriverio/tree/main/packages/wdio-sauce-service",
@@ -24,11 +24,11 @@
   },
   "dependencies": {
     "@types/node": "^17.0.4",
-    "@wdio/logger": "7.16.0",
-    "@wdio/types": "7.16.14",
-    "@wdio/utils": "7.17.0",
+    "@wdio/logger": "7.17.3",
+    "@wdio/types": "7.17.3",
+    "@wdio/utils": "7.17.3",
     "saucelabs": "^7.1.3",
-    "webdriverio": "7.17.0"
+    "webdriverio": "7.17.3"
   },
   "peerDependencies": {
     "@wdio/cli": "^7.0.0"
@@ -37,5 +37,5 @@
     "access": "public"
   },
   "types": "./build/index.d.ts",
-  "gitHead": "e18d2cde6ff979758830bdff4c3bc82ca9818b24"
+  "gitHead": "2bcb589dbdd10ca181f301a269b4dd158faab257"
 }