init: browserstack service code

Author: Ankit098

LICENSE-MIT

@@ -0,0 +1,20 @@
+Copyright (c) OpenJS Foundation and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

browserstack-service.d.ts

@@ -0,0 +1,43 @@
+declare module WebdriverIO {
+    interface ServiceOption extends BrowserstackConfig {}
+
+    interface Suite {
+        title: string;
+        fullName: string;
+        file: string;
+    }
+
+    interface Test extends Suite {
+        parent: string;
+        passed: boolean;
+    }
+
+    interface TestResult {
+        exception: string;
+        status: string;
+    }
+}
+
+interface BrowserstackConfig {
+    /**
+     * Set this to true to enable routing connections from Browserstack cloud through your computer.
+     * You will also need to set `browserstack.local` to true in browser capabilities.
+     */
+    browserstackLocal?: boolean;
+    /**
+     * Cucumber only. Set this to true to enable updating the session name to the Scenario name if only
+     * a single Scenario was ran. Useful when running in parallel
+     * with [wdio-cucumber-parallel-execution](https://github.com/SimitTomar/wdio-cucumber-parallel-execution).
+     */
+    preferScenarioName?: boolean;
+    /**
+     * Set this to true to kill the browserstack process on complete, without waiting for the
+     * browserstack stop callback to be called. This is experimental and should not be used by all.
+     */
+    forcedStop?: boolean;
+    /**
+     * Specified optional will be passed down to BrowserstackLocal. See this list for details:
+     * https://stackoverflow.com/questions/39040108/import-class-in-definition-file-d-ts
+     */
+    opts?: Partial<import('browserstack-local').Options>
+}

src/@types/cucumber-framework.d.ts

@@ -0,0 +1,15 @@
+declare module WebdriverIO {
+    interface Config extends CucumberOptsConfig {}
+}
+
+interface CucumberOptsConfig {
+    cucumberOpts?: CucumberOpts
+}
+
+interface CucumberOpts {
+    /**
+     * Fail if there are any undefined or pending steps
+     * @default false
+     */
+    strict?: boolean
+}

src/constants.ts

@@ -0,0 +1,10 @@
+export const BROWSER_DESCRIPTION = [
+    'device',
+    'os',
+    'osVersion',
+    'os_version',
+    'browserName',
+    'browser',
+    'browserVersion',
+    'browser_version'
+] as const

src/index.ts

@@ -0,0 +1,15 @@
+/* istanbul ignore file */
+
+import BrowserstackLauncher from './launcher'
+import BrowserstackService from './service'
+import type { BrowserstackConfig } from './types'
+
+export default BrowserstackService
+export const launcher = BrowserstackLauncher
+export * from './types'
+
+declare global {
+    namespace WebdriverIO {
+        interface ServiceOption extends BrowserstackConfig {}
+    }
+}

src/launcher.ts

@@ -0,0 +1,123 @@
+import { promisify } from 'util'
+import { performance, PerformanceObserver } from 'perf_hooks'
+
+import * as BrowserstackLocalLauncher from 'browserstack-local'
+import logger from '@wdio/logger'
+import type { Capabilities, Services, Options } from '@wdio/types'
+
+import { BrowserstackConfig } from './types'
+
+const log = logger('@wdio/browserstack-service')
+
+type BrowserstackLocal = BrowserstackLocalLauncher.Local & {
+    pid?: number;
+    stop(callback: (err?: any) => void): void;
+}
+
+export default class BrowserstackLauncherService implements Services.ServiceInstance {
+    browserstackLocal?: BrowserstackLocal
+
+    constructor (
+        private _options: BrowserstackConfig,
+        capabilities: Capabilities.RemoteCapability,
+        private _config: Options.Testrunner
+    ) {}
+
+    onPrepare (config?: Options.Testrunner, capabilities?: Capabilities.RemoteCapabilities) {
+        if (!this._options.browserstackLocal) {
+            return log.info('browserstackLocal is not enabled - skipping...')
+        }
+
+        const opts = {
+            key: this._config.key,
+            forcelocal: true,
+            onlyAutomate: true,
+            ...this._options.opts
+        }
+
+        this.browserstackLocal = new BrowserstackLocalLauncher.Local()
+
+        if (Array.isArray(capabilities)) {
+            capabilities.forEach((capability: Capabilities.DesiredCapabilities) => {
+                if (!capability['bstack:options']) {
+                    capability['bstack:options'] = {}
+                }
+                capability['bstack:options'].local = true
+            })
+        } else if (typeof capabilities === 'object') {
+            Object.entries(capabilities as Capabilities.MultiRemoteCapabilities).forEach(([, caps]) => {
+                if (!(caps.capabilities as Capabilities.Capabilities)['bstack:options']) {
+                    (caps.capabilities as Capabilities.Capabilities)['bstack:options'] = {}
+                }
+                (caps.capabilities as Capabilities.Capabilities)['bstack:options']!.local = true
+            })
+        } else {
+            throw TypeError('Capabilities should be an object or Array!')
+        }
+
+        /**
+         * measure TestingBot tunnel boot time
+         */
+        const obs = new PerformanceObserver((list) => {
+            const entry = list.getEntries()[0]
+            log.info(`Browserstack Local successfully started after ${entry.duration}ms`)
+        })
+
+        obs.observe({ entryTypes: ['measure'] })
+
+        let timer: NodeJS.Timeout
+        performance.mark('tbTunnelStart')
+        return Promise.race([
+            promisify(this.browserstackLocal.start.bind(this.browserstackLocal))(opts),
+            new Promise((resolve, reject) => {
+                /* istanbul ignore next */
+                timer = setTimeout(function () {
+                    reject('Browserstack Local failed to start within 60 seconds!')
+                }, 60000)
+            })]
+        ).then(function (result) {
+            clearTimeout(timer)
+            performance.mark('tbTunnelEnd')
+            performance.measure('bootTime', 'tbTunnelStart', 'tbTunnelEnd')
+            return Promise.resolve(result)
+        }, function (err) {
+            clearTimeout(timer)
+            return Promise.reject(err)
+        })
+    }
+
+    onComplete () {
+        if (!this.browserstackLocal || !this.browserstackLocal.isRunning()) {
+            return
+        }
+
+        if (this._options.forcedStop) {
+            return process.kill(this.browserstackLocal.pid as number)
+        }
+
+        let timer: NodeJS.Timeout
+        return Promise.race([
+            new Promise<void>((resolve, reject) => {
+                this.browserstackLocal?.stop((err: Error) => {
+                    if (err) {
+                        return reject(err)
+                    }
+                    resolve()
+                })
+            }),
+            new Promise((resolve, reject) => {
+                /* istanbul ignore next */
+                timer = setTimeout(
+                    () => reject(new Error('Browserstack Local failed to stop within 60 seconds!')),
+                    60000
+                )
+            })]
+        ).then(function (result) {
+            clearTimeout(timer)
+            return Promise.resolve(result)
+        }, function (err) {
+            clearTimeout(timer)
+            return Promise.reject(err)
+        })
+    }
+}