@wdio/local-runner 7.17.0 → 7.17.3

package/build/constants.d.ts

@@ -0,0 +1,7 @@
+export declare const SHUTDOWN_TIMEOUT = 5000;
+export declare const DEBUGGER_MESSAGES: string[];
+export declare const BUFFER_OPTIONS: {
+    initialSize: number;
+    incrementAmount: number;
+};
+//# 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,eAAO,MAAM,gBAAgB,OAAO,CAAA;AAEpC,eAAO,MAAM,iBAAiB,UAI7B,CAAA;AAED,eAAO,MAAM,cAAc;;;CAG1B,CAAA"}

package/build/constants.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BUFFER_OPTIONS = exports.DEBUGGER_MESSAGES = exports.SHUTDOWN_TIMEOUT = void 0;
+exports.SHUTDOWN_TIMEOUT = 5000;
+exports.DEBUGGER_MESSAGES = [
+    'Debugger listening on',
+    'Debugger attached',
+    'Waiting for the debugger'
+];
+exports.BUFFER_OPTIONS = {
+    initialSize: (1000 * 1024),
+    incrementAmount: (100 * 1024) // grow by 10 kilobytes each time buffer overflows.
+};

package/build/index.d.ts

@@ -0,0 +1,29 @@
+import { WritableStreamBuffer } from 'stream-buffers';
+import type { Options, Workers } from '@wdio/types';
+import WorkerInstance from './worker';
+interface RunArgs extends Workers.WorkerRunPayload {
+    command: string;
+    args: any;
+}
+export default class LocalRunner {
+    private _config;
+    workerPool: Record<string, WorkerInstance>;
+    stdout: WritableStreamBuffer;
+    stderr: WritableStreamBuffer;
+    constructor(configFile: unknown, _config: Options.Testrunner);
+    /**
+     * nothing to initialise when running locally
+     */
+    initialise(): void;
+    getWorkerCount(): number;
+    run({ command, args, ...workerOptions }: RunArgs): WorkerInstance;
+    /**
+     * shutdown all worker processes
+     *
+     * @return {Promise}  resolves when all worker have been shutdown or
+     *                    a timeout was reached
+     */
+    shutdown(): Promise<void>;
+}
+export {};
+//# 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":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAA;AACrD,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAA;AAEnD,OAAO,cAAc,MAAM,UAAU,CAAA;AAKrC,UAAU,OAAQ,SAAQ,OAAO,CAAC,gBAAgB;IAC9C,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,GAAG,CAAA;CACZ;AAED,MAAM,CAAC,OAAO,OAAO,WAAW;IAQxB,OAAO,CAAC,OAAO;IAPnB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAK;IAE/C,MAAM,uBAA2C;IACjD,MAAM,uBAA2C;gBAG7C,UAAU,EAAE,OAAO,EACX,OAAO,EAAE,OAAO,CAAC,UAAU;IAGvC;;OAEG;IACH,UAAU;IAEV,cAAc;IAId,GAAG,CAAE,EAAE,OAAO,EAAE,IAAI,EAAE,GAAG,aAAa,EAAE,EAAE,OAAO;IAiBjD;;;;;OAKG;IACH,QAAQ;CA2CX"}

package/build/index.js

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger_1 = __importDefault(require("@wdio/logger"));
+const stream_buffers_1 = require("stream-buffers");
+const worker_1 = __importDefault(require("./worker"));
+const constants_1 = require("./constants");
+const log = (0, logger_1.default)('@wdio/local-runner');
+class LocalRunner {
+    constructor(configFile, _config) {
+        this._config = _config;
+        this.workerPool = {};
+        this.stdout = new stream_buffers_1.WritableStreamBuffer(constants_1.BUFFER_OPTIONS);
+        this.stderr = new stream_buffers_1.WritableStreamBuffer(constants_1.BUFFER_OPTIONS);
+    }
+    /**
+     * nothing to initialise when running locally
+     */
+    initialise() { }
+    getWorkerCount() {
+        return Object.keys(this.workerPool).length;
+    }
+    run({ command, args, ...workerOptions }) {
+        /**
+         * adjust max listeners on stdout/stderr when creating listeners
+         */
+        const workerCnt = this.getWorkerCount();
+        if (workerCnt >= process.stdout.getMaxListeners() - 2) {
+            process.stdout.setMaxListeners(workerCnt + 2);
+            process.stderr.setMaxListeners(workerCnt + 2);
+        }
+        const worker = new worker_1.default(this._config, workerOptions, this.stdout, this.stderr);
+        this.workerPool[workerOptions.cid] = worker;
+        worker.postMessage(command, args);
+        return worker;
+    }
+    /**
+     * shutdown all worker processes
+     *
+     * @return {Promise}  resolves when all worker have been shutdown or
+     *                    a timeout was reached
+     */
+    shutdown() {
+        log.info('Shutting down spawned worker');
+        for (const [cid, worker] of Object.entries(this.workerPool)) {
+            const { caps, server, sessionId, config, isMultiremote, instances } = worker;
+            let payload = {};
+            /**
+             * put connection information to payload if in watch mode
+             * in order to attach to browser session and kill it
+             */
+            if (config && config.watch && (sessionId || isMultiremote)) {
+                payload = {
+                    config: { ...server, sessionId },
+                    caps,
+                    watch: true,
+                    isMultiremote,
+                    instances
+                };
+            }
+            else if (!worker.isBusy) {
+                delete this.workerPool[cid];
+                continue;
+            }
+            worker.postMessage('endSession', payload);
+        }
+        return new Promise((resolve) => {
+            const timeout = setTimeout(resolve, constants_1.SHUTDOWN_TIMEOUT);
+            const interval = setInterval(() => {
+                const busyWorker = Object.entries(this.workerPool)
+                    .filter(([, worker]) => worker.isBusy).length;
+                log.info(`Waiting for ${busyWorker} to shut down gracefully`);
+                if (busyWorker === 0) {
+                    clearTimeout(timeout);
+                    clearInterval(interval);
+                    log.info('shutting down');
+                    return resolve();
+                }
+            }, 250);
+        });
+    }
+}
+exports.default = LocalRunner;

package/build/repl.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+import vm from 'vm';
+import WDIORepl, { ReplConfig, ReplCallback } from '@wdio/repl';
+import type { ChildProcess } from 'child_process';
+export default class WDIORunnerRepl extends WDIORepl {
+    childProcess: ChildProcess;
+    callback?: ReplCallback;
+    commandIsRunning: boolean;
+    constructor(childProcess: ChildProcess, options: ReplConfig);
+    private _getError;
+    eval(cmd: string, context: vm.Context, filename: string, callback: ReplCallback): void;
+    onResult(params: any): void;
+    start(context?: vm.Context): Promise<unknown>;
+}
+//# sourceMappingURL=repl.d.ts.map

package/build/repl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repl.d.ts","sourceRoot":"","sources":["../src/repl.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,MAAM,IAAI,CAAA;AAEnB,OAAO,QAAQ,EAAE,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAC/D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AAEjD,MAAM,CAAC,OAAO,OAAO,cAAe,SAAQ,QAAQ;IAChD,YAAY,EAAE,YAAY,CAAA;IAC1B,QAAQ,CAAC,EAAE,YAAY,CAAA;IACvB,gBAAgB,UAAQ;gBAEX,YAAY,EAAE,YAAY,EAAE,OAAO,EAAE,UAAU;IAK5D,OAAO,CAAC,SAAS;IAUjB,IAAI,CAAE,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,EAAE,CAAC,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY;IAehF,QAAQ,CAAE,MAAM,EAAE,GAAG;IAUrB,KAAK,CAAE,OAAO,CAAC,EAAE,EAAE,CAAC,OAAO;CAQ9B"}

package/build/repl.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const repl_1 = __importDefault(require("@wdio/repl"));
+class WDIORunnerRepl extends repl_1.default {
+    constructor(childProcess, options) {
+        super(options);
+        this.commandIsRunning = false;
+        this.childProcess = childProcess;
+    }
+    _getError(params) {
+        if (!params.error) {
+            return null;
+        }
+        const err = new Error(params.message);
+        err.stack = params.stack;
+        return err;
+    }
+    eval(cmd, context, filename, callback) {
+        if (this.commandIsRunning) {
+            return;
+        }
+        this.commandIsRunning = true;
+        this.childProcess.send({
+            origin: 'debugger',
+            name: 'eval',
+            content: { cmd }
+        });
+        this.callback = callback;
+    }
+    onResult(params) {
+        const error = this._getError(params);
+        if (this.callback) {
+            this.callback(error, params.result);
+        }
+        this.commandIsRunning = false;
+    }
+    start(context) {
+        this.childProcess.send({
+            origin: 'debugger',
+            name: 'start'
+        });
+        return super.start(context);
+    }
+}
+exports.default = WDIORunnerRepl;

package/build/replQueue.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+import type { ChildProcess } from 'child_process';
+import WDIORepl from './repl';
+/**
+ * repl queue class
+ * allows to run debug commands in mutliple workers one after another
+ */
+export default class ReplQueue {
+    private _repls;
+    runningRepl?: WDIORepl;
+    add(childProcess: ChildProcess, options: any, onStart: Function, onEnd: Function): void;
+    next(): void;
+    get isRunning(): boolean;
+}
+//# sourceMappingURL=replQueue.d.ts.map

package/build/replQueue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replQueue.d.ts","sourceRoot":"","sources":["../src/replQueue.ts"],"names":[],"mappings":";AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AAEjD,OAAO,QAAQ,MAAM,QAAQ,CAAA;AAS7B;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,SAAS;IAC1B,OAAO,CAAC,MAAM,CAAa;IAC3B,WAAW,CAAC,EAAE,QAAQ,CAAA;IAEtB,GAAG,CAAE,YAAY,EAAE,YAAY,EAAE,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,QAAQ;IAIjF,IAAI;IA2BJ,IAAI,SAAS,YAEZ;CACJ"}

package/build/replQueue.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const repl_1 = __importDefault(require("./repl"));
+/**
+ * repl queue class
+ * allows to run debug commands in mutliple workers one after another
+ */
+class ReplQueue {
+    constructor() {
+        this._repls = [];
+    }
+    add(childProcess, options, onStart, onEnd) {
+        this._repls.push({ childProcess, options, onStart, onEnd });
+    }
+    next() {
+        if (this.isRunning || this._repls.length === 0) {
+            return;
+        }
+        const nextRepl = this._repls.shift();
+        if (!nextRepl) {
+            return;
+        }
+        const { childProcess, options, onStart, onEnd } = nextRepl;
+        const runningRepl = this.runningRepl = new repl_1.default(childProcess, options);
+        onStart();
+        runningRepl.start().then(() => {
+            const ev = {
+                origin: 'debugger',
+                name: 'stop'
+            };
+            runningRepl.childProcess.send(ev);
+            onEnd(ev);
+            delete this.runningRepl;
+            this.next();
+        });
+    }
+    get isRunning() {
+        return Boolean(this.runningRepl);
+    }
+}
+exports.default = ReplQueue;

package/build/run.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+/**
+ * ToDo(Christian): remove when @wdio/runner got typed
+ */
+interface RunnerInterface extends NodeJS.EventEmitter {
+    sigintWasCalled: boolean;
+    [key: string]: any;
+}
+export declare const runner: RunnerInterface;
+/**
+ * catch sigint messages as they are handled by main process
+ */
+export declare const exitHookFn: (callback: () => void) => void;
+export {};
+//# sourceMappingURL=run.d.ts.map

package/build/run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../src/run.ts"],"names":[],"mappings":";AAUA;;GAEG;AACH,UAAU,eAAgB,SAAQ,MAAM,CAAC,YAAY;IACjD,eAAe,EAAE,OAAO,CAAA;IACxB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CACrB;AAED,eAAO,MAAM,MAAM,iBAA6C,CAAA;AA8BhE;;GAEG;AACH,eAAO,MAAM,UAAU,aAAc,MAAM,IAAI,SAQ9C,CAAA"}

package/build/run.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exitHookFn = exports.runner = void 0;
+const async_exit_hook_1 = __importDefault(require("async-exit-hook"));
+const runner_1 = __importDefault(require("@wdio/runner"));
+const logger_1 = __importDefault(require("@wdio/logger"));
+const constants_1 = require("./constants");
+const log = (0, logger_1.default)('@wdio/local-runner');
+exports.runner = new runner_1.default();
+exports.runner.on('exit', process.exit.bind(process));
+exports.runner.on('error', ({ name, message, stack }) => process.send({
+    origin: 'worker',
+    name: 'error',
+    content: { name, message, stack }
+}));
+process.on('message', (m) => {
+    if (!m || !m.command) {
+        return;
+    }
+    log.info(`Run worker command: ${m.command}`);
+    exports.runner[m.command](m).then((result) => process.send({
+        origin: 'worker',
+        name: 'finisedCommand',
+        content: {
+            command: m.command,
+            result
+        }
+    }), (e) => {
+        log.error(`Failed launching test session: ${e.stack}`);
+        setTimeout(() => process.exit(1), 10);
+    });
+});
+/**
+ * catch sigint messages as they are handled by main process
+ */
+const exitHookFn = (callback) => {
+    if (!callback) {
+        return;
+    }
+    exports.runner.sigintWasCalled = true;
+    log.info(`Received SIGINT, giving process ${constants_1.SHUTDOWN_TIMEOUT}ms to shutdown gracefully`);
+    setTimeout(callback, constants_1.SHUTDOWN_TIMEOUT);
+};
+exports.exitHookFn = exitHookFn;
+(0, async_exit_hook_1.default)(exports.exitHookFn);

package/build/stdStream.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+import { Transform, TransformCallback } from 'stream';
+export default class RunnerStream extends Transform {
+    constructor();
+    _transform(chunk: any, encoding: BufferEncoding, callback: TransformCallback): void;
+    _final(callback: (error?: Error | undefined) => void): void;
+}
+//# sourceMappingURL=stdStream.d.ts.map

package/build/stdStream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stdStream.d.ts","sourceRoot":"","sources":["../src/stdStream.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,QAAQ,CAAA;AAGrD,MAAM,CAAC,OAAO,OAAO,YAAa,SAAQ,SAAS;;IAgB/C,UAAU,CAAE,KAAK,EAAE,GAAG,EAAE,QAAQ,EAAE,cAAc,EAAE,QAAQ,EAAE,iBAAiB,GAAG,IAAI;IAIpF,MAAM,CAAE,QAAQ,EAAE,CAAC,KAAK,CAAC,EAAE,KAAK,GAAG,SAAS,KAAK,IAAI,GAAG,IAAI;CAI/D"}

package/build/stdStream.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const stream_1 = require("stream");
+const utils_1 = require("./utils");
+class RunnerStream extends stream_1.Transform {
+    constructor() {
+        super();
+        /**
+         * Remove events that are automatically created by Writable stream
+         */
+        this.on('pipe', () => {
+            (0, utils_1.removeLastListener)(this, 'close');
+            (0, utils_1.removeLastListener)(this, 'drain');
+            (0, utils_1.removeLastListener)(this, 'error');
+            (0, utils_1.removeLastListener)(this, 'finish');
+            (0, utils_1.removeLastListener)(this, 'unpipe');
+        });
+    }
+    _transform(chunk, encoding, callback) {
+        callback(undefined, chunk);
+    }
+    _final(callback) {
+        this.unpipe();
+        callback();
+    }
+}
+exports.default = RunnerStream;

package/build/transformStream.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+import { Readable } from 'stream';
+export default function runnerTransformStream(cid: string, inputStream: Readable): Readable;
+//# sourceMappingURL=transformStream.d.ts.map

package/build/transformStream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transformStream.d.ts","sourceRoot":"","sources":["../src/transformStream.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,QAAQ,EAAgC,MAAM,QAAQ,CAAA;AAG/D,MAAM,CAAC,OAAO,UAAU,qBAAqB,CAAC,GAAG,EAAE,MAAM,EAAE,WAAW,EAAE,QAAQ,GAAG,QAAQ,CAK1F"}

package/build/transformStream.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const split = require("split2");
+const stream_1 = require("stream");
+const constants_1 = require("./constants");
+function runnerTransformStream(cid, inputStream) {
+    return inputStream
+        .pipe(split(/\r?\n/, line => `${line}\n`))
+        .pipe(ignore(constants_1.DEBUGGER_MESSAGES))
+        .pipe(map(line => `[${cid}] ${line}`));
+}
+exports.default = runnerTransformStream;
+function ignore(patternsToIgnore) {
+    return new stream_1.Transform({
+        decodeStrings: false,
+        transform(chunk, encoding, next) {
+            if (patternsToIgnore.some(m => chunk.startsWith(m))) {
+                return next();
+            }
+            return next(null, chunk);
+        },
+        final(next) {
+            this.unpipe();
+            next();
+        },
+    });
+}
+function map(mapper) {
+    return new stream_1.Transform({
+        decodeStrings: false,
+        transform(chunk, encoding, next) {
+            return next(null, mapper(chunk));
+        },
+        final(next) {
+            this.unpipe();
+            next();
+        },
+    });
+}

package/build/utils.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+import type { Transform } from 'stream';
+export declare function removeLastListener(target: Transform, eventName: string): void;
+//# 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,SAAS,EAAE,MAAM,QAAQ,CAAA;AAEvC,wBAAgB,kBAAkB,CAAE,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,CAK9E"}

package/build/utils.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeLastListener = void 0;
+function removeLastListener(target, eventName) {
+    const listener = target.listeners(eventName).reverse()[0];
+    if (listener) {
+        target.removeListener(eventName, listener);
+    }
+}
+exports.removeLastListener = removeLastListener;

package/build/worker.d.ts

@@ -0,0 +1,56 @@
+/// <reference types="node" />
+import child from 'child_process';
+import { EventEmitter } from 'events';
+import type { WritableStreamBuffer } from 'stream-buffers';
+import type { ChildProcess } from 'child_process';
+import type { Capabilities, Options, Workers } from '@wdio/types';
+/**
+ * WorkerInstance
+ * responsible for spawning a sub process to run the framework in and handle its
+ * session lifetime.
+ */
+export default class WorkerInstance extends EventEmitter implements Workers.Worker {
+    cid: string;
+    config: Options.Testrunner;
+    configFile: string;
+    caps: Capabilities.RemoteCapability;
+    capabilities: Capabilities.RemoteCapability;
+    specs: string[];
+    execArgv: string[];
+    retries: number;
+    stdout: WritableStreamBuffer;
+    stderr: WritableStreamBuffer;
+    childProcess?: ChildProcess;
+    sessionId?: string;
+    server?: Record<string, any>;
+    instances?: Record<string, {
+        sessionId: string;
+    }>;
+    isMultiremote?: boolean;
+    isBusy: boolean;
+    /**
+     * assigns paramters to scope of instance
+     * @param  {object}   config      parsed configuration object
+     * @param  {string}   cid         capability id (e.g. 0-1)
+     * @param  {string}   configFile  path to config file (for sub process to parse)
+     * @param  {object}   caps        capability object
+     * @param  {string[]} specs       list of paths to test files to run in this worker
+     * @param  {number}   retries     number of retries remaining
+     * @param  {object}   execArgv    execution arguments for the test run
+     */
+    constructor(config: Options.Testrunner, { cid, configFile, caps, specs, execArgv, retries }: Workers.WorkerRunPayload, stdout: WritableStreamBuffer, stderr: WritableStreamBuffer);
+    /**
+     * spawns process to kick of wdio-runner
+     */
+    startProcess(): child.ChildProcess;
+    private _handleMessage;
+    private _handleError;
+    private _handleExit;
+    /**
+     * sends message to sub process to execute functions in wdio-runner
+     * @param  command  method to run in wdio-runner
+     * @param  args     arguments for functions to call
+     */
+    postMessage(command: string, args: Workers.WorkerMessageArgs): void;
+}
+//# sourceMappingURL=worker.d.ts.map

package/build/worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker.d.ts","sourceRoot":"","sources":["../src/worker.ts"],"names":[],"mappings":";AACA,OAAO,KAAK,MAAM,eAAe,CAAA;AACjC,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAA;AACrC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAA;AAC1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AACjD,OAAO,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAA;AAgBjE;;;;GAIG;AACH,MAAM,CAAC,OAAO,OAAO,cAAe,SAAQ,YAAa,YAAW,OAAO,CAAC,MAAM;IAC9E,GAAG,EAAE,MAAM,CAAA;IACX,MAAM,EAAE,OAAO,CAAC,UAAU,CAAA;IAC1B,UAAU,EAAE,MAAM,CAAA;IAClB,IAAI,EAAE,YAAY,CAAC,gBAAgB,CAAA;IACnC,YAAY,EAAE,YAAY,CAAC,gBAAgB,CAAA;IAC3C,KAAK,EAAE,MAAM,EAAE,CAAA;IACf,QAAQ,EAAE,MAAM,EAAE,CAAA;IAClB,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,oBAAoB,CAAA;IAC5B,MAAM,EAAE,oBAAoB,CAAA;IAC5B,YAAY,CAAC,EAAE,YAAY,CAAA;IAC3B,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IAE5B,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;IACjD,aAAa,CAAC,EAAE,OAAO,CAAA;IAEvB,MAAM,UAAQ;IAEd;;;;;;;;;OASG;gBAEC,MAAM,EAAE,OAAO,CAAC,UAAU,EAC1B,EAAE,GAAG,EAAE,UAAU,EAAE,IAAI,EAAE,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,EAAE,OAAO,CAAC,gBAAgB,EAC7E,MAAM,EAAE,oBAAoB,EAC5B,MAAM,EAAE,oBAAoB;IAehC;;OAEG;IACH,YAAY;IAsCZ,OAAO,CAAC,cAAc;IA8CtB,OAAO,CAAC,YAAY;IAKpB,OAAO,CAAC,WAAW;IAiBnB;;;;OAIG;IACH,WAAW,CAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,CAAC,iBAAiB,GAAG,IAAI;CAmBvE"}

package/build/worker.js

@@ -0,0 +1,158 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const child_process_1 = __importDefault(require("child_process"));
+const events_1 = require("events");
+const logger_1 = __importDefault(require("@wdio/logger"));
+const transformStream_1 = __importDefault(require("./transformStream"));
+const replQueue_1 = __importDefault(require("./replQueue"));
+const stdStream_1 = __importDefault(require("./stdStream"));
+const log = (0, logger_1.default)('@wdio/local-runner');
+const replQueue = new replQueue_1.default();
+const stdOutStream = new stdStream_1.default();
+const stdErrStream = new stdStream_1.default();
+stdOutStream.pipe(process.stdout);
+stdErrStream.pipe(process.stderr);
+/**
+ * WorkerInstance
+ * responsible for spawning a sub process to run the framework in and handle its
+ * session lifetime.
+ */
+class WorkerInstance extends events_1.EventEmitter {
+    /**
+     * assigns paramters to scope of instance
+     * @param  {object}   config      parsed configuration object
+     * @param  {string}   cid         capability id (e.g. 0-1)
+     * @param  {string}   configFile  path to config file (for sub process to parse)
+     * @param  {object}   caps        capability object
+     * @param  {string[]} specs       list of paths to test files to run in this worker
+     * @param  {number}   retries     number of retries remaining
+     * @param  {object}   execArgv    execution arguments for the test run
+     */
+    constructor(config, { cid, configFile, caps, specs, execArgv, retries }, stdout, stderr) {
+        super();
+        this.isBusy = false;
+        this.cid = cid;
+        this.config = config;
+        this.configFile = configFile;
+        this.caps = caps;
+        this.capabilities = caps;
+        this.specs = specs;
+        this.execArgv = execArgv;
+        this.retries = retries;
+        this.stdout = stdout;
+        this.stderr = stderr;
+    }
+    /**
+     * spawns process to kick of wdio-runner
+     */
+    startProcess() {
+        const { cid, execArgv } = this;
+        const argv = process.argv.slice(2);
+        const runnerEnv = Object.assign({}, process.env, this.config.runnerEnv, {
+            WDIO_WORKER: true
+        });
+        if (this.config.outputDir) {
+            runnerEnv.WDIO_LOG_PATH = path_1.default.join(this.config.outputDir, `wdio-${cid}.log`);
+        }
+        log.info(`Start worker ${cid} with arg: ${argv}`);
+        const childProcess = this.childProcess = child_process_1.default.fork(path_1.default.join(__dirname, 'run.js'), argv, {
+            cwd: process.cwd(),
+            env: runnerEnv,
+            execArgv,
+            stdio: ['inherit', 'pipe', 'pipe', 'ipc']
+        });
+        childProcess.on('message', this._handleMessage.bind(this));
+        childProcess.on('error', this._handleError.bind(this));
+        childProcess.on('exit', this._handleExit.bind(this));
+        /* istanbul ignore if */
+        if (!process.env.JEST_WORKER_ID) {
+            if (childProcess.stdout !== null) {
+                (0, transformStream_1.default)(cid, childProcess.stdout).pipe(stdOutStream);
+            }
+            if (childProcess.stderr !== null) {
+                (0, transformStream_1.default)(cid, childProcess.stderr).pipe(stdErrStream);
+            }
+        }
+        return childProcess;
+    }
+    _handleMessage(payload) {
+        var _a;
+        const { cid, childProcess } = this;
+        /**
+         * resolve pending commands
+         */
+        if (payload.name === 'finisedCommand') {
+            this.isBusy = false;
+        }
+        /**
+         * store sessionId and connection data to worker instance
+         */
+        if (payload.name === 'sessionStarted') {
+            if (payload.content.isMultiremote) {
+                Object.assign(this, payload.content);
+            }
+            else {
+                this.sessionId = payload.content.sessionId;
+                delete payload.content.sessionId;
+            }
+            return;
+        }
+        /**
+         * handle debug command called within worker process
+         */
+        if (childProcess && payload.origin === 'debugger' && payload.name === 'start') {
+            replQueue.add(childProcess, { prompt: `[${cid}] \u203A `, ...payload.params }, () => this.emit('message', Object.assign(payload, { cid })), (ev) => this.emit('message', ev));
+            return replQueue.next();
+        }
+        /**
+         * handle debugger results
+         */
+        if (replQueue.isRunning && payload.origin === 'debugger' && payload.name === 'result') {
+            (_a = replQueue.runningRepl) === null || _a === void 0 ? void 0 : _a.onResult(payload.params);
+        }
+        this.emit('message', Object.assign(payload, { cid }));
+    }
+    _handleError(payload) {
+        const { cid } = this;
+        this.emit('error', Object.assign(payload, { cid }));
+    }
+    _handleExit(exitCode) {
+        const { cid, childProcess, specs, retries } = this;
+        /**
+         * delete process of worker
+         */
+        delete this.childProcess;
+        this.isBusy = false;
+        log.debug(`Runner ${cid} finished with exit code ${exitCode}`);
+        this.emit('exit', { cid, exitCode, specs, retries });
+        if (childProcess) {
+            childProcess.kill('SIGTERM');
+        }
+    }
+    /**
+     * sends message to sub process to execute functions in wdio-runner
+     * @param  command  method to run in wdio-runner
+     * @param  args     arguments for functions to call
+     */
+    postMessage(command, args) {
+        const { cid, configFile, caps, specs, retries, isBusy } = this;
+        if (isBusy && command !== 'endSession') {
+            return log.info(`worker with cid ${cid} already busy and can't take new commands`);
+        }
+        /**
+         * start up process if worker hasn't done yet or if child process
+         * closes after running its job
+         */
+        if (!this.childProcess) {
+            this.childProcess = this.startProcess();
+        }
+        const cmd = { cid, command, configFile, args, caps, specs, retries };
+        this.childProcess.send(cmd);
+        this.isBusy = true;
+    }
+}
+exports.default = WorkerInstance;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wdio/local-runner",
-  "version": "7.17.0",
+  "version": "7.17.3",
   "description": "A WebdriverIO runner to run tests locally",
   "author": "Christian Bromann <christian@saucelabs.com>",
   "homepage": "https://github.com/webdriverio/webdriverio/tree/main/packages/wdio-local-runner",
@@ -24,10 +24,10 @@
   },
   "dependencies": {
     "@types/stream-buffers": "^3.0.3",
-    "@wdio/logger": "7.16.0",
-    "@wdio/repl": "7.17.0",
-    "@wdio/runner": "7.17.0",
-    "@wdio/types": "7.16.14",
+    "@wdio/logger": "7.17.3",
+    "@wdio/repl": "7.17.3",
+    "@wdio/runner": "7.17.3",
+    "@wdio/types": "7.17.3",
     "async-exit-hook": "^2.0.1",
     "split2": "^4.0.0",
     "stream-buffers": "^3.0.2"
@@ -39,5 +39,5 @@
     "access": "public"
   },
   "types": "./build/index.d.ts",
-  "gitHead": "e18d2cde6ff979758830bdff4c3bc82ca9818b24"
+  "gitHead": "2bcb589dbdd10ca181f301a269b4dd158faab257"
 }