detox 20.0.14-is-hittable-over-master.0 → 20.0.14-prerelease.0

package/src/logger/utils/DetoxLogFinalizer.js

@@ -0,0 +1,134 @@
+const path = require('path');
+const { promisify } = require('util');
+
+const fs = require('fs-extra');
+const glob = require('glob');
+const pipe = require('multipipe');
+
+const temporary = require('../../artifacts/utils/temporaryPath');
+
+const globAsync = promisify(glob);
+const globSync = glob.sync;
+const streamUtils = () => require('../../logger/utils/streamUtils');
+
+/**
+ * @typedef DetoxLogFinalizerConfig
+ * @property {import('../../ipc/SessionState')} session
+ */
+
+class DetoxLogFinalizer {
+  /** @param {DetoxLogFinalizerConfig} config */
+  constructor(config) {
+    this._session = config.session;
+  }
+
+  createEventStream() {
+    const sessionId = this._session.id;
+    const logs = globSync(temporary.for.jsonl(`${sessionId}.*`));
+
+    return streamUtils()
+      .uniteSessionLogs(logs)
+      .pipe(streamUtils().chromeTraceStream());
+  }
+
+  async finalize() {
+    const sessionId = this._session.id;
+    const logs = await globAsync(temporary.for.jsonl(`${sessionId}.*`));
+    if (logs.length === 0) {
+      return;
+    }
+
+    if (this._areLogsEnabled()) {
+      const rootDir = this._config.artifacts.rootDir;
+
+      await fs.mkdirp(rootDir);
+      const [out1Stream, out2Stream] = ['detox.log', 'detox.trace.json']
+        .map((filename) => fs.createWriteStream(path.join(rootDir, filename)));
+
+      const tidHashMap = await this._scanForThreadIds(logs);
+      const mergedStream = streamUtils().uniteSessionLogs(logs);
+
+      await Promise.all([
+        pipe(mergedStream, streamUtils().debugStream(this._config.logger.options), out1Stream),
+        pipe(mergedStream, streamUtils().chromeTraceStream(tidHashMap), streamUtils().writeJSON(), out2Stream),
+      ]);
+    }
+
+    await Promise.all(logs.map(filepath => fs.remove(filepath)));
+  }
+
+  finalizeSync() {
+    const sessionId = this._session.id;
+    const rootDir = this._config.artifacts.rootDir;
+    const logsEnabled = this._areLogsEnabled();
+
+    if (logsEnabled) {
+      fs.mkdirpSync(rootDir);
+    }
+
+    const logs = globSync(temporary.for.jsonl(`${sessionId}.*`));
+
+    for (const log of logs) {
+      if (logsEnabled) {
+        fs.moveSync(log, path.join(rootDir, path.basename(log)));
+      } else {
+        fs.removeSync(log);
+      }
+    }
+  }
+
+  /** @private */
+  get _config() {
+    // The config appears later in the lifecycle, so we need to access it lazily
+    return this._session.detoxConfig;
+  }
+
+  /** @private */
+  _areLogsEnabled() {
+    const { rootDir, plugins } = this._config.artifacts;
+    if (!rootDir || !plugins) {
+      return false;
+    }
+
+    if (!plugins.log.enabled) {
+      return false;
+    }
+
+    if (!plugins.log.keepOnlyFailedTestsArtifacts) {
+      return true;
+    }
+
+    return this._session.testResults.some(r => !r.success);
+  }
+
+  /** @private */
+  async _scanForThreadIds(logs) {
+    const processes = await new Promise((resolve, reject) => {
+      const result = {};
+      streamUtils().uniteSessionLogs(logs)
+        .on('end', () => resolve(result))
+        .on('error', (err) => reject(err))
+        .on('data', (event) => {
+          const { ph, pid, tid, cat } = event;
+          if (ph === 'B' || ph === 'i') {
+            const categories = (result[pid] = result[pid] || {});
+            const mainCategory = String(cat).split(',')[0];
+            const tids = (categories[mainCategory] = categories[mainCategory] || []);
+            if (!tids.includes(tid)) {
+              tids.push(tid);
+            }
+          }
+        });
+    });
+
+    const tidArray = Object.entries(processes).flatMap(([pid, categories]) => {
+      return Object.entries(categories).flatMap(([category, tids]) => {
+        return tids.map(tid => `${pid}:${category}:${tid}`);
+      });
+    });
+
+    return new Map(tidArray.map((hash, index) => [hash, index]));
+  }
+}
+
+module.exports = DetoxLogFinalizer;

package/src/logger/utils/ThreadDispatcher.js

@@ -2,17 +2,10 @@ const isUndefined = (x) => x === undefined;
 
 class ThreadDispatcher {
   /**
-   * @param {object} options
-   * @param {Detox.Logger} options.logger
-   * @param {string} options.name
-   * @param {number} options.min
-   * @param {number} [options.max]
+   * @param {string} name
    */
-  constructor({ logger, name, min, max = Infinity }) {
-    this.logger = logger;
+  constructor(name) {
     this.name = name;
-    this.min = min;
-    this.max = max;
     this.stacks = [];
     this.threads = [];
   }
@@ -25,7 +18,7 @@ class ThreadDispatcher {
     const tid = this._findTID(id);
     this.threads[tid] = id;
     this.stacks[tid] = (this.stacks[tid] || 0) + 1;
-    return this._transpose(tid);
+    return tid;
   }
 
   /**
@@ -33,8 +26,7 @@ class ThreadDispatcher {
    * @returns {number}
    */
   resolve(id) {
-    const tid = this._findTID(id);
-    return this._transpose(tid);
+    return this._findTID(id);
   }
 
   /**
@@ -46,7 +38,7 @@ class ThreadDispatcher {
     if (this.stacks[tid] && --this.stacks[tid] === 0) {
       delete this.threads[tid];
     }
-    return this._transpose(tid);
+    return tid;
   }
 
   /**
@@ -64,18 +56,6 @@ class ThreadDispatcher {
     }
     return tid === -1 ? this.threads.length : tid;
   }
-
-  _transpose(id) {
-    const result = this.min + id;
-    if (result > this.max) {
-      this.logger.warn(
-        { cat: ['logger', 'thread-dispatcher'] },
-        `${this.name} trace thread dispatcher has run out of available thread IDs: ${this.min}..${this.max}`
-      );
-    }
-
-    return Math.min(result, this.max);
-  }
 }
 
 module.exports = ThreadDispatcher;

package/src/logger/utils/customConsoleLogger.js

@@ -25,20 +25,20 @@ function getStackDump() {
 
 function proxyLog(bunyanLoggerFn) {
   return (...args) => {
-    bunyanLoggerFn({ origin: getOrigin() }, util.format(...args));
+    bunyanLoggerFn({ cat: 'user', origin: getOrigin() }, util.format(...args));
   };
 }
 
 function proxyTracing(bunyanLoggerFn) {
   return (...args) => {
-    bunyanLoggerFn({ origin: getOrigin(), stack: getStackDump() }, util.format(...args));
+    bunyanLoggerFn({ cat: 'user', origin: getOrigin(), stack: getStackDump() }, util.format(...args));
   };
 }
 
 function proxyAssert(bunyanLoggerFn) {
   return (condition, ...args) => {
     if (!condition) {
-      bunyanLoggerFn({ origin: getOrigin() }, 'AssertionError:', util.format(...args));
+      bunyanLoggerFn({ cat: 'user', origin: getOrigin() }, 'AssertionError:', util.format(...args));
     }
   };
 }
@@ -48,6 +48,7 @@ function overrideConsoleMethods(console, bunyanLogger) {
     const log = bunyanLogger;
 
     override(console, 'log', log.info.bind(log));
+    override(console, 'info', log.info.bind(log));
     override(console, 'warn', log.warn.bind(log));
     override(console, 'trace', log.info.bind(log));
     override(console, 'error', log.error.bind(log));

package/src/logger/utils/streamUtils.js

@@ -3,14 +3,12 @@ const { PassThrough, Transform } = require('stream');
 const bunyanDebugStream = require('bunyan-debug-stream');
 const duplexify = require('duplexify');
 const fs = require('fs-extra');
-const glob = require('glob');
 const multiSort = require('multi-sort-stream');
 const pipe = require('multipipe');
 const JsonlParser = require('stream-json/jsonl/Parser');
 const stripAnsi = require('strip-ansi');
 const { AbstractEventBuilder } = require('trace-event-lib');
 
-const temporary = require('../../artifacts/utils/temporaryPath');
 const log = require('../../utils/logger').child({ cat: 'logger' });
 
 function compareTimestamps(a, b) {
@@ -143,27 +141,49 @@ class SimpleEventBuilder extends AbstractEventBuilder {
   }
 }
 
-function chromeTraceStream() {
+const ERROR_TID = 37707;
+
+function getTidHash({ pid, tid, cat }) {
+  const mainCategory = String(cat).split(',')[0];
+  return `${pid}:${mainCategory}:${tid}`;
+}
+
+function getFixedTID(tidHashMap, event) {
+  let tid = tidHashMap.get(getTidHash(event));
+  if (tid === undefined) {
+    tid = ERROR_TID;
+  }
+
+  return tid;
+}
+
+/**
+ * @param {Map<string, number>} [tidHashMap]
+ */
+function chromeTraceStream(tidHashMap) {
   const knownPids = new Set();
   const knownTids = new Set();
+  const fixTID = tidHashMap ? getFixedTID.bind(null, tidHashMap) : (x) => x.tid;
 
   return flatMapTransform((data) => {
     // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars
-    const { cat = 'default', msg: name, ph = 'i', pid, tid, time, name: _name, hostname: _hostname, ...args } = data;
+    const { cat: rawCat, msg: name, ph = 'i', pid, tid: _tid, time, name: _name, hostname: _hostname, ...args } = data;
     const ts = new Date(time).getTime() * 1E3;
+    const cat = rawCat || 'undefined';
+    const tid = fixTID(data);
 
     const builder = new SimpleEventBuilder();
     if (!knownPids.has(pid)) {
-      builder.process_name(pid === process.pid ? 'primary' : 'secondary', pid);
+      builder.metadata({ pid, ts, name: 'process_name', args: { name: pid === process.pid ? 'primary' : 'secondary' } });
+      builder.metadata({ pid, ts, name: 'process_sort_index', args: { sort_index: knownPids.size } });
       knownPids.add(pid);
     }
 
-    const tidHash = `${pid}:${tid}`;
-    if (!knownTids.has(tidHash)) {
+    if (!knownTids.has(tid)) {
       const primaryCategory = cat.split(',', 1)[0];
-      builder.thread_name(primaryCategory, tid, pid);
-      builder.thread_sort_index(tid, tid, pid);
-      knownTids.add(tidHash);
+      builder.metadata({ pid, tid, ts, name: 'thread_name', args: { name: primaryCategory } });
+      builder.metadata({ pid, tid, ts, name: 'thread_sort_index', args: { sort_index: tid } });
+      knownTids.add(tid);
     }
 
     const event = { ph, name, pid, tid, cat, ts, args };
@@ -207,25 +227,13 @@ function readJSONL() {
 }
 
 /**
- * @param {string} sessionId
+ * @param {string[]} logs
  * @returns {NodeJS.ReadableStream}
  */
-function uniteSessionLogs(sessionId) {
+function uniteSessionLogs(logs) {
   const readable = through();
-
-  glob(temporary.for.jsonl(`${sessionId}.*`), function (err, logs) {
-    if (err) {
-      return readable.emit('error', err);
-    }
-
-    if (logs.length === 0) {
-      return;
-    }
-
-    const jsonlStreams = logs.map(filePath => fs.createReadStream(filePath).pipe(readJSONL()));
-    mergeSortedJSONL(jsonlStreams).pipe(readable);
-  });
-
+  const jsonlStreams = logs.map(filePath => fs.createReadStream(filePath).pipe(readJSONL()));
+  mergeSortedJSONL(jsonlStreams).pipe(readable);
   return readable;
 }
 

package/src/realms/DetoxContext.js

@@ -2,16 +2,19 @@ const funpermaproxy = require('funpermaproxy');
 
 const temporary = require('../artifacts/utils/temporaryPath');
 const { DetoxRuntimeError } = require('../errors');
-const { DetoxLogger, installLegacyTracerInterface } = require('../logger');
+const { DetoxLogger, DetoxLogFinalizer, installLegacyTracerInterface } = require('../logger');
 const symbols = require('../symbols');
 
 const DetoxConstants = require('./DetoxConstants');
 
+//#region Protected symbols
 const $cleanup = Symbol('cleanup');
+const $logFinalizer = Symbol('logFinalizer');
 const $restoreSessionState = Symbol('restoreSessionState');
 const $sessionState = Symbol('restoreSessionState');
 const $status = Symbol('status');
 const $worker = Symbol('worker');
+//#endregion
 
 class DetoxContext {
   constructor() {
@@ -56,6 +59,10 @@ class DetoxContext {
     this.log = this[symbols.logger].child({ cat: 'user' });
     installLegacyTracerInterface(this.log, this);
 
+    this[$logFinalizer] = new DetoxLogFinalizer({
+      session: this[$sessionState]
+    });
+
     /** @type {import('../DetoxWorker') | null} */
     this[$worker] = null;
   }
@@ -80,27 +87,16 @@ class DetoxContext {
   //#endregion
 
   //#region Internal members
-  [symbols.onRunStart] = (...args) => this[symbols.worker].onRunStart(...args);
   [symbols.onRunDescribeStart] = (...args) => this[symbols.worker].onRunDescribeStart(...args);
   [symbols.onTestStart] = (...args) => this[symbols.worker].onTestStart(...args);
-  [symbols.onHookStart] = (...args) => this[symbols.worker].onHookStart(...args);
   [symbols.onHookFailure] = (...args) => this[symbols.worker].onHookFailure(...args);
-  [symbols.onHookSuccess] = (...args) => this[symbols.worker].onHookSuccess(...args);
-  [symbols.onTestFnStart] = (...args) => this[symbols.worker].onTestFnStart(...args);
   [symbols.onTestFnFailure] = (...args) => this[symbols.worker].onTestFnFailure(...args);
-  [symbols.onTestFnSuccess] = (...args) => this[symbols.worker].onTestFnSuccess(...args);
   [symbols.onTestDone] = (...args) => this[symbols.worker].onTestDone(...args);
   [symbols.onRunDescribeFinish] = (...args) => this[symbols.worker].onRunDescribeFinish(...args);
-  [symbols.onRunFinish] = (...args) => this[symbols.worker].onRunFinish(...args);
   [symbols.config] = funpermaproxy(() => this[symbols.session].detoxConfig);
   [symbols.session] = funpermaproxy(() => this[$sessionState]);
   [symbols.tracing] = Object.freeze({
-    createEventStream: () => {
-      const streamUtils = require('../logger/utils/streamUtils');
-      return streamUtils
-        .uniteSessionLogs(this[$sessionState].id)
-        .pipe(streamUtils.chromeTraceStream());
-    },
+    createEventStream: () => this[$logFinalizer].createEventStream(),
   });
   /** @abstract */
   [symbols.reportTestResults](_testResults) {}
@@ -179,6 +175,7 @@ class DetoxContext {
 module.exports = DetoxContext;
 module.exports.protected = {
   $cleanup,
+  $logFinalizer,
   $restoreSessionState,
   $status,
   $sessionState,

package/src/realms/DetoxInternalsFacade.js

@@ -15,16 +15,10 @@ class DetoxInternalsFacade {
     this.installWorker = context[symbols.installWorker];
     this.uninstallWorker = context[symbols.uninstallWorker];
     this.onHookFailure = context[symbols.onHookFailure];
-    this.onHookStart = context[symbols.onHookStart];
-    this.onHookSuccess = context[symbols.onHookSuccess];
     this.onRunDescribeFinish = context[symbols.onRunDescribeFinish];
     this.onRunDescribeStart = context[symbols.onRunDescribeStart];
-    this.onRunFinish = context[symbols.onRunFinish];
-    this.onRunStart = context[symbols.onRunStart];
     this.onTestDone = context[symbols.onTestDone];
     this.onTestFnFailure = context[symbols.onTestFnFailure];
-    this.onTestFnStart = context[symbols.onTestFnStart];
-    this.onTestFnSuccess = context[symbols.onTestFnSuccess];
     this.onTestStart = context[symbols.onTestStart];
     this.reportTestResults = context[symbols.reportTestResults];
     this.resolveConfig = context[symbols.resolveConfig];

package/src/realms/DetoxPrimaryContext.js

@@ -1,34 +1,30 @@
-const path = require('path');
 const { URL } = require('url');
-const { promisify } = require('util');
 
 const fs = require('fs-extra');
-const glob = require('glob');
-const pipe = require('multipipe');
 const onSignalExit = require('signal-exit');
 
 const temporary = require('../artifacts/utils/temporaryPath');
 const { DetoxRuntimeError } = require('../errors');
 const SessionState = require('../ipc/SessionState');
 const symbols = require('../symbols');
-
-const globAsync = promisify(glob);
-const globSync = glob.sync;
+const { getCurrentCommand } = require('../utils/argparse');
+const uuid = require('../utils/uuid');
 
 const DetoxContext = require('./DetoxContext');
 
-const { $restoreSessionState, $sessionState, $worker } = DetoxContext.protected;
+// Protected symbols
+const { $logFinalizer, $restoreSessionState, $sessionState, $worker } = DetoxContext.protected;
 
-const _finalizeLogs = Symbol('finalizeLogs');
-const _finalizeLogsSync = Symbol('finalizeLogsSync');
+//#region Private symbols
 const _globalLifecycleHandler = Symbol('globalLifecycleHandler');
 const _ipcServer = Symbol('ipcServer');
 const _resetLockFile = Symbol('resetLockFile');
 const _wss = Symbol('wss');
 const _dirty = Symbol('dirty');
 const _emergencyTeardown = Symbol('emergencyTeardown');
-const _areLogsEnabled = Symbol('areLogsEnabled');
 const _lifecycleLogger = Symbol('lifecycleLogger');
+const _sessionFile = Symbol('sessionFile');
+//#endregion
 
 class DetoxPrimaryContext extends DetoxContext {
   constructor() {
@@ -37,6 +33,8 @@ class DetoxPrimaryContext extends DetoxContext {
     this[_dirty] = false;
     this[_wss] = null;
     this[_globalLifecycleHandler] = null;
+    /** Path to file where the initial session object is serialized */
+    this[_sessionFile] = '';
     /**
      * @type {import('../ipc/IPCServer') | null}
      */
@@ -88,8 +86,9 @@ class DetoxPrimaryContext extends DetoxContext {
     await this[symbols.logger].setConfig(loggerConfig);
 
     this[_lifecycleLogger].trace.begin({
+      cwd: process.cwd(),
       data: this[$sessionState],
-    }, process.argv.slice(1).join(' '));
+    }, getCurrentCommand());
 
     const IPCServer = require('../ipc/IPCServer');
     this[_ipcServer] = new IPCServer({
@@ -127,8 +126,10 @@ class DetoxPrimaryContext extends DetoxContext {
       sessionConfig.server = `ws://localhost:${this[_wss].port}`;
     }
 
-    await fs.writeFile(this[$sessionState].detoxConfigSnapshotPath, this[$sessionState].stringify());
-    process.env.DETOX_CONFIG_SNAPSHOT_PATH = this[$sessionState].detoxConfigSnapshotPath;
+    this[_sessionFile] = temporary.for.json(this[$sessionState].id);
+    await fs.writeFile(this[_sessionFile], this[$sessionState].stringify());
+    process.env.DETOX_CONFIG_SNAPSHOT_PATH = this[_sessionFile];
+    this[_lifecycleLogger].trace(`Serialized the session state at: ${this[_sessionFile]}`);
 
     if (opts.workerId !== null) {
       await this[symbols.installWorker](opts);
@@ -140,10 +141,12 @@ class DetoxPrimaryContext extends DetoxContext {
    * @param {Partial<DetoxInternals.DetoxInstallWorkerOptions>} [opts]
    */
   async [symbols.installWorker](opts = {}) {
-    const workerId = this[$sessionState].workerId = opts.workerId = opts.workerId || 'worker';
+    const workerId = opts.workerId || 'worker';
+
+    this[$sessionState].workerId = workerId;
     this[_ipcServer].onRegisterWorker({ workerId });
 
-    await super[symbols.installWorker](opts);
+    await super[symbols.installWorker]({ ...opts, workerId });
   }
 
   /** @override */
@@ -168,12 +171,14 @@ class DetoxPrimaryContext extends DetoxContext {
         this[_ipcServer] = null;
       }
 
-      await fs.remove(this[$sessionState].detoxConfigSnapshotPath);
+      if (this[_sessionFile]) {
+        await fs.remove(this[_sessionFile]);
+      }
 
       if (this[_dirty]) {
         try {
           this[_lifecycleLogger].trace.end();
-          await this[_finalizeLogs]();
+          await this[$logFinalizer].finalize();
         } catch (err) {
           this[_lifecycleLogger].error({ err }, 'Encountered an error while merging the process logs:');
         }
@@ -199,9 +204,13 @@ class DetoxPrimaryContext extends DetoxContext {
       this[_ipcServer].dispose();
     }
 
+    if (this[_sessionFile]) {
+      fs.removeSync(this[_sessionFile]);
+    }
+
     try {
       this[_lifecycleLogger].trace.end({ abortSignal: signal });
-      this[_finalizeLogsSync]();
+      this[$logFinalizer].finalizeSync();
     } catch (err) {
       this[symbols.logger].error({ err }, 'Encountered an error while merging the process logs:');
     }
@@ -217,77 +226,13 @@ class DetoxPrimaryContext extends DetoxContext {
    */
   [$restoreSessionState]() {
     return new SessionState({
-      detoxConfigSnapshotPath: temporary.for.json(),
+      id: uuid.UUID(),
       detoxIPCServer: `primary-${process.pid}`,
     });
   }
   //#endregion
 
   //#region Private members
-  async[_finalizeLogs]() {
-    const sessionId = this[$sessionState].id;
-    const logs = await globAsync(temporary.for.jsonl(`${sessionId}.*`));
-    if (logs.length === 0) {
-      return;
-    }
-
-    if (this[_areLogsEnabled]()) {
-      const streamUtils = require('../logger/utils/streamUtils');
-      const { rootDir } = this[symbols.config].artifacts;
-
-      await fs.mkdirp(rootDir);
-      const [out1Stream, out2Stream] = ['detox.log', 'detox.trace.json']
-        .map((filename) => fs.createWriteStream(path.join(rootDir, filename)));
-
-      const mergedStream = streamUtils.uniteSessionLogs(sessionId);
-
-      await Promise.all([
-        pipe(mergedStream, streamUtils.debugStream(this[symbols.logger].config.options), out1Stream),
-        pipe(mergedStream, streamUtils.chromeTraceStream(), streamUtils.writeJSON(), out2Stream),
-      ]);
-    }
-
-    await Promise.all(logs.map(filepath => fs.remove(filepath)));
-  }
-
-  async[_finalizeLogsSync]() {
-    const logsEnabled = this[_areLogsEnabled]();
-
-    const { rootDir } = this[symbols.config].artifacts;
-
-    if (logsEnabled) {
-      fs.mkdirpSync(rootDir);
-    }
-
-    const sessionId = this[$sessionState].id;
-    const logs = globSync(temporary.for.jsonl(`${sessionId}.*`));
-
-    for (const log of logs) {
-      if (logsEnabled) {
-        fs.moveSync(log, path.join(rootDir, path.basename(log)));
-      } else {
-        fs.removeSync(log);
-      }
-    }
-  }
-
-  [_areLogsEnabled]() {
-    const { rootDir, plugins } = this[symbols.config].artifacts || {};
-    if (!rootDir || !plugins) {
-      return false;
-    }
-
-    if (!plugins.log.enabled) {
-      return false;
-    }
-
-    if (!plugins.log.keepOnlyFailedTestsArtifacts) {
-      return true;
-    }
-
-    return this[$sessionState].testResults.some(r => !r.success);
-  }
-
   async[_resetLockFile]() {
     const DeviceRegistry = require('../devices/DeviceRegistry');
 

package/src/realms/DetoxSecondaryContext.js

@@ -6,9 +6,12 @@ const symbols = require('../symbols');
 
 const DetoxContext = require('./DetoxContext');
 
+// Protected symbols
 const { $restoreSessionState, $sessionState, $worker } = DetoxContext.protected;
+
+//#region Private symbols
 const _ipcClient = Symbol('ipcClient');
-const _shortLifecycle = Symbol('shortLifecycle');
+//#endregion
 
 class DetoxSecondaryContext extends DetoxContext {
   constructor() {
@@ -19,13 +22,6 @@ class DetoxSecondaryContext extends DetoxContext {
      * @type {import('../ipc/IPCClient')}
      */
     this[_ipcClient] = null;
-    /**
-     * @private
-     * @type {undefined | boolean}
-     *
-     * TODO: explain what is short lifecycle and why we need it
-     */
-    this[_shortLifecycle] = false;
   }
 
   //#region Internal members
@@ -74,9 +70,9 @@ class DetoxSecondaryContext extends DetoxContext {
 
   /** @override */
   async [symbols.installWorker](opts = {}) {
-    const workerId = opts.workerId = opts.workerId || 'worker';
+    const workerId = opts.workerId || 'worker';
     await this[_ipcClient].registerWorker(workerId);
-    await super[symbols.installWorker](opts);
+    await super[symbols.installWorker]({ ...opts, workerId });
   }
   //#endregion