detox 20.0.0-breaking.new-global-lifecycle.0 → 20.0.3-breaking.new-global-lifecycle.0

package/local-cli/test.test.js

@@ -116,7 +116,7 @@ describe('CLI', () => {
     });
   });
 
-  test('should use runnerConfig.specs as default specs', async () => {
+  test('should use testRunner.args._ as default specs', async () => {
     detoxConfig.testRunner.args._ = ['e2e/sanity'];
     await run();
     expect(_.last(cliCall().argv)).toEqual('e2e/sanity');
@@ -140,26 +140,32 @@ describe('CLI', () => {
 
   test.each([['-R'], ['--retries']])('%s <value> should execute unsuccessful run N extra times', async (__retries) => {
     const context = require('../internals');
-    context.session.failedTestFiles = ['e2e/failing1.test.js', 'e2e/failing2.test.js'];
-    context.session.failedTestFiles.splice = jest.fn(() => {
-      context.session.failedTestFiles = ['e2e/failing2.test.js'];
-    });
+    context.session.testFilesToRetry = ['e2e/failing1.test.js', 'e2e/failing2.test.js'];
+    context.session.testFilesToRetry.splice = jest.fn()
+      .mockImplementationOnce(() => ['e2e/failing1.test.js', 'e2e/failing2.test.js'])
+      .mockImplementationOnce(() => ['e2e/failing2.test.js']);
 
     mockExitCode(1);
 
     await run(__retries, 2).catch(_.noop);
 
-    expect(cliCall(0).env).not.toHaveProperty('DETOX_RERUN_INDEX');
     expect(cliCall(0).argv).toEqual([expect.stringMatching(/executable$/), '--config', 'e2e/config.json']);
-    expect(cliCall(0).fullCommand).not.toMatch(/DETOX_RERUN_INDEX/);
-
-    expect(cliCall(1).env.DETOX_RERUN_INDEX).toBe('1');
     expect(cliCall(1).argv).toEqual([expect.stringMatching(/executable$/), '--config', 'e2e/config.json', 'e2e/failing1.test.js', 'e2e/failing2.test.js']);
-    expect(cliCall(1).fullCommand).not.toMatch(/DETOX_RERUN_INDEX/);
-
     expect(cliCall(2).argv).toEqual([expect.stringMatching(/executable$/), '--config', 'e2e/config.json', 'e2e/failing2.test.js']);
-    expect(cliCall(2).env.DETOX_RERUN_INDEX).toBe('2');
-    expect(cliCall(2).fullCommand).not.toMatch(/DETOX_RERUN_INDEX/);
+  });
+
+  test.each([['-R'], ['--retries']])('%s <value> should bail if has permanently failed tests', async (__retries) => {
+    const context = require('../internals');
+    context.session.failedTestFiles = ['e2e/failing1.test.js'];
+    context.session.testFilesToRetry = ['e2e/failing2.test.js'];
+
+    mockExitCode(1);
+
+    await run(__retries, 2).catch(_.noop);
+
+    expect(cliCall(0).env).not.toHaveProperty('DETOX_RERUN_INDEX');
+    expect(cliCall(0).argv).toEqual([expect.stringMatching(/executable$/), '--config', 'e2e/config.json']);
+    expect(cliCall(1)).toBe(null);
   });
 
   test.each([['-R'], ['--retries']])('%s <value> should not restart test runner if there are no failing tests paths', async (__retries) => {
@@ -172,7 +178,7 @@ describe('CLI', () => {
 
   test.each([['-R'], ['--retries']])('%s <value> should retain -- <...explicitPassthroughArgs>', async (__retries) => {
     const context = require('../internals');
-    context.session.failedTestFiles = ['tests/failing.test.js'];
+    context.session.testFilesToRetry = ['tests/failing.test.js'];
 
     mockExitCode(1);
 

package/local-cli/testCommand/TestRunnerCommand.js

@@ -88,7 +88,7 @@ class TestRunnerCommand {
       try {
         if (launchError) {
           const list = this._argv._.map((file, index) => `  ${index + 1}. ${file}`).join('\n');
-          detox.log.error(
+          detox.log.error({ event: 'RETRY_RUN' },
             `There were failing tests in the following files:\n${list}\n\n` +
             'Detox CLI is going to restart the test runner with those files...\n'
           );
@@ -99,14 +99,14 @@ class TestRunnerCommand {
       } catch (e) {
         launchError = e;
 
-        const { failedTestFiles } = detox.session;
-        if (_.isEmpty(failedTestFiles)) {
+        const { failedTestFiles, testFilesToRetry } = detox.session;
+        if (!_.isEmpty(failedTestFiles) || _.isEmpty(testFilesToRetry)) {
           throw e;
         }
 
-        this._argv._ = failedTestFiles.slice();
-        this._env.DETOX_RERUN_INDEX = 1 + (this._env.DETOX_RERUN_INDEX || 0);
-        detox.session.failedTestFiles.splice(0, Infinity);
+        this._argv._ = testFilesToRetry.splice(0, Infinity);
+        // @ts-ignore
+        detox.session.testSessionIndex++; // it is always a primary context, so we can update it
       }
     } while (launchError && --runsLeft > 0);
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "detox",
   "description": "E2E tests and automation for mobile",
-  "version": "20.0.0-breaking.new-global-lifecycle.0",
+  "version": "20.0.3-breaking.new-global-lifecycle.0",
   "bin": {
     "detox": "local-cli/cli.js"
   },
@@ -46,10 +46,10 @@
     "eslint-plugin-no-only-tests": "^2.6.0",
     "eslint-plugin-node": "^11.1.0",
     "eslint-plugin-unicorn": "^39.0.0",
-    "jest": "^27.5.1",
+    "jest": "^28.0.0",
     "mockdate": "^2.0.1",
     "prettier": "1.7.0",
-    "react-native": "0.67.2",
+    "react-native": "0.68.2",
     "react-native-codegen": "^0.0.8",
     "typescript": "^4.5.2",
     "wtfnode": "^0.9.1"
@@ -183,5 +183,5 @@
       }
     }
   },
-  "gitHead": "e89c826fdbd09989dcb1cc82eb3cc7d821ffbf3e"
+  "gitHead": "1e9a8a54aa4c8d73cf106770522723d0f6f1f10e"
 }

package/runners/jest/testEnvironment/index.js

@@ -46,7 +46,7 @@ class DetoxCircusEnvironment extends NodeEnvironment {
     /** @protected */
     this.testEventListeners = [];
     /** @protected */
-    this.initTimeout = detox.config.runnerConfig.jest.initTimeout;
+    this.initTimeout = detox.config.testRunner.jest.initTimeout;
   }
 
   /** @override */

package/runners/jest/testEnvironment/listeners/DetoxCoreListener.js

@@ -16,18 +16,13 @@ class DetoxCoreListener {
   }
 
   _getTestInvocations(test) {
-    const { DETOX_RERUN_INDEX } = process.env;
-
-    if (!isNaN(DETOX_RERUN_INDEX)) {
-      return Number(DETOX_RERUN_INDEX) * this._testRunTimes + test.invocations;
-    } else {
-      return test.invocations;
-    }
+    const { testSessionIndex } = detoxInternals.session;
+    return testSessionIndex * this._testRunTimes + test.invocations;
   }
 
   async setup() {
     // Workaround to override Jest's expect
-    if (detoxInternals.config.behaviorConfig.init.exposeGlobals) {
+    if (detoxInternals.config.behavior.init.exposeGlobals) {
       this._env.global.expect = detox.expect;
     }
   }
@@ -103,7 +98,8 @@ class DetoxCoreListener {
 
   async run_finish(_event, state) {
     if (this._hasFailedTests(state.rootDescribeBlock)) {
-      await detoxInternals.reportFailedTests([this._env.testPath]);
+      const handledByJestCircus = this._testRunTimes > 1 && !detoxInternals.config.testRunner.jest.retryAfterCircusRetries;
+      await detoxInternals.reportFailedTests([this._env.testPath], handledByJestCircus);
     }
   }
 

package/runners/jest/testEnvironment/listeners/SpecReporter.js

@@ -16,7 +16,7 @@ class SpecReporter {
   }
 
   get enabled() {
-    const jestSection = config.runnerConfig.jest;
+    const jestSection = config.testRunner.jest;
     const reportSpecs = jestSection && jestSection.reportSpecs;
 
     return reportSpecs !== undefined ? reportSpecs : session.workersCount === 1;

package/runners/jest/testEnvironment/listeners/WorkerAssignReporter.js

@@ -12,7 +12,7 @@ class WorkerAssignReporter {
   }
 
   run_start() {
-    if (config.runnerConfig.jest.reportWorkerAssign) {
+    if (config.testRunner.jest.reportWorkerAssign) {
       log.info({ event: 'WORKER_ASSIGN' }, `${this._formatTestName()} is assigned to ${this._formatDeviceName()}`);
     }
   }

package/src/DetoxWorker.js

@@ -56,7 +56,13 @@ class DetoxWorker {
   async init() {
     if (this._isCleaningUp) return;
 
-    const { appsConfig, artifactsConfig, behaviorConfig, deviceConfig, sessionConfig } = this._config;
+    const {
+      apps: appsConfig,
+      artifacts: artifactsConfig,
+      behavior: behaviorConfig,
+      device: deviceConfig,
+      session: sessionConfig
+    } = this._config;
     this._appsConfig = appsConfig;
     this._artifactsConfig = artifactsConfig;
     this._behaviorConfig = behaviorConfig;
@@ -232,6 +238,11 @@ class DetoxWorker {
       if (this._isCleaningUp) return;
       await this.device.uninstallApp();
       if (this._isCleaningUp) return;
+    }
+
+    for (const appName of appNames) {
+      await this.device.selectApp(appName);
+      if (this._isCleaningUp) return;
       await this.device.installApp();
       if (this._isCleaningUp) return;
     }

package/src/artifacts/log/android/ADBLogcatRecording.js

@@ -1,6 +1,5 @@
 const DetoxRuntimeError = require('../../../errors/DetoxRuntimeError');
 const { interruptProcess } = require('../../../utils/childProcess');
-const log = require('../../../utils/logger').child({ __filename });
 const retry = require('../../../utils/retry');
 const sleep = require('../../../utils/sleep');
 const Artifact = require('../../templates/artifact/Artifact');
@@ -26,26 +25,18 @@ class ADBLogcatRecording extends Artifact {
     this._waitUntilLogFileIsCreated = null;
   }
 
-  get hasRecordedFile() {
-    return !!this._waitUntilLogFileIsCreated;
-  }
-
   async doStart() {
     const pid = this.pid.get();
 
-    if (pid > 0) {
-      this.processPromise = this.adb.logcat(this.deviceId, {
-        file: this.pathToLogOnDevice,
-        time: this.since.get(),
-        pid,
-      });
+    this.processPromise = this.adb.logcat(this.deviceId, {
+      file: this.pathToLogOnDevice,
+      time: this.since.get(),
+      pid: pid > 0 ? pid : 0,
+    });
 
-      this._waitUntilLogFileIsCreated = sleep(300).then(() => {
-        return retry(() => this._assertLogIsCreated());
-      });
-    } else {
-      log.debug('Ignoring a command to start recording, because PID of the app is missing');
-    }
+    this._waitUntilLogFileIsCreated = sleep(300).then(() => {
+      return retry(() => this._assertLogIsCreated());
+    });
   }
 
   async doStop() {
@@ -61,20 +52,12 @@ class ADBLogcatRecording extends Artifact {
   }
 
   async doSave(artifactPath) {
-    if (this.hasRecordedFile) {
-      await this.adb.pull(this.deviceId, this.pathToLogOnDevice, artifactPath);
-      await this.adb.rm(this.deviceId, this.pathToLogOnDevice);
-    } else {
-      log.debug(`Skipping saving artifact because the recording has not started: ${artifactPath}`);
-    }
+    await this.adb.pull(this.deviceId, this.pathToLogOnDevice, artifactPath);
+    await this.adb.rm(this.deviceId, this.pathToLogOnDevice);
   }
 
   async doDiscard() {
-    if (this.hasRecordedFile) {
-      await this.adb.rm(this.deviceId, this.pathToLogOnDevice);
-    } else {
-      log.debug(`Skipping discarding artifact due to a not started recording: ${this.pathToLogOnDevice}`);
-    }
+    await this.adb.rm(this.deviceId, this.pathToLogOnDevice);
   }
 
   async _assertLogIsCreated() {

package/src/configuration/composeAppsConfig.js

@@ -1,6 +1,6 @@
 // @ts-nocheck
 const _ = require('lodash');
-const parse = require('yargs/yargs').Parser;
+const parse = require('yargs-parser');
 
 const deviceAppTypes = require('./utils/deviceAppTypes');
 

package/src/configuration/composeRunnerConfig.js

@@ -2,6 +2,8 @@ const os = require('os');
 
 const _ = require('lodash');
 
+const log = require('../utils/logger');
+
 /**
  * @param {object} opts
  * @param {Detox.DetoxConfig} opts.globalConfig
@@ -12,7 +14,7 @@ const _ = require('lodash');
  * @returns {Detox.DetoxTestRunnerConfig} opts.testRunnerArgv
  */
 function composeRunnerConfig(opts) {
-  const globalConfig = opts.globalConfig.testRunner;
+  const globalConfig = adaptLegacyRunnerConfig(opts.globalConfig);
   if (globalConfig != null && typeof globalConfig !== 'object') {
     throw opts.errorComposer.invalidTestRunnerProperty(true);
   }
@@ -31,6 +33,7 @@ function composeRunnerConfig(opts) {
       inspectBrk: inspectBrkHookDefault,
       jest: {
         initTimeout: 300000,
+        retryAfterCircusRetries: false,
         reportSpecs: undefined,
         reportWorkerAssign: true,
       },
@@ -60,6 +63,51 @@ function composeRunnerConfig(opts) {
   return merged;
 }
 
+function adaptLegacyRunnerConfig(globalConfig) {
+  let isLegacy = false;
+
+  const runnerConfigKey = 'runnerConfig' in globalConfig ? 'runnerConfig' : 'runner-config';
+  if (_.isString(globalConfig[runnerConfigKey])) {
+    isLegacy = true;
+    log.warn(`Detected a deprecated "${runnerConfigKey}" property (string).`);
+  }
+
+  const testRunnerKey = 'testRunner' in globalConfig ? 'testRunner' : 'test-runner';
+  if (_.isString(globalConfig[testRunnerKey])) {
+    isLegacy = true;
+    log.warn(`Detected a deprecated "${testRunnerKey}" property (string).`);
+  }
+
+  if (globalConfig.specs != null) {
+    isLegacy = true;
+    log.warn(`Detected a deprecated "specs" property.`);
+  }
+
+  if (!isLegacy) {
+    return globalConfig.testRunner;
+  }
+
+  log.warn(`Please migrate your Detox config according to the guide: [TODO: insert the migration guilde link]`);
+  const testRunner = globalConfig[testRunnerKey];
+  const runnerConfig = globalConfig[runnerConfigKey];
+  const specs = globalConfig.specs != null ? String(globalConfig.specs) : undefined;
+
+  const args = {};
+  if (_.isString(testRunner)) {
+    args.$0 = testRunner;
+  }
+
+  if (_.isString(runnerConfig)) {
+    args.config = runnerConfig;
+  }
+
+  if (specs) {
+    args._ = [specs];
+  }
+
+  return { args };
+}
+
 function hasEmptyPositionalArgs(value, key) {
   return key === '_' ? _.isEmpty(value) : false;
 }

package/src/configuration/index.js

@@ -105,16 +105,17 @@ async function composeDetoxConfig({
   });
 
   const result = {
-    appsConfig,
-    artifactsConfig,
-    behaviorConfig,
-    cliConfig,
     configurationName,
-    deviceConfig,
     errorComposer,
-    loggerConfig,
-    runnerConfig,
-    sessionConfig,
+
+    apps: appsConfig,
+    artifacts: artifactsConfig,
+    behavior: behaviorConfig,
+    cli: cliConfig,
+    device: deviceConfig,
+    logger: loggerConfig,
+    testRunner: runnerConfig,
+    session: sessionConfig,
   };
 
   return result;

package/src/devices/allocation/drivers/android/genycloud/GenyAllocDriver.js

@@ -40,6 +40,7 @@ class GenyAllocDriver extends AllocationDriverBase {
     const { adbName } = instance;
 
     await this._adb.disableAndroidAnimations(adbName);
+    await this._adb.setWiFiToggle(adbName, true);
     await this._adb.apiLevel(adbName);
     return new GenycloudEmulatorCookie(instance);
   }

package/src/devices/common/drivers/android/exec/ADB.js

@@ -206,6 +206,11 @@ class ADB {
     await this.shell(deviceId, `settings put global transition_animation_scale 0`);
   }
 
+  async setWiFiToggle(deviceId, state) {
+    const value = (state === true ? 'enable' : 'disable');
+    await this.shell(deviceId, `svc wifi ${value}`);
+  }
+
   async screencap(deviceId, path) {
     await this.shell(deviceId, `screencap ${path}`);
   }

package/src/errors/DetoxConfigErrorComposer.js

@@ -409,7 +409,7 @@ Please check your Detox config${this._atPath()}`,
       case 'gpuMode':
         return this._unsupportedPropertyByDeviceType('gpuMode', ['android.emulator'], deviceAlias);
       case 'headless':
-        return this._unsupportedPropertyByDeviceType('headless', ['android.emulator'], deviceAlias);
+        return this._unsupportedPropertyByDeviceType('headless', ['ios.simulator', 'android.emulator'], deviceAlias);
       case 'readonly':
         return this._unsupportedPropertyByDeviceType('readonly', ['android.emulator'], deviceAlias);
       case 'utilBinaryPaths':
@@ -656,12 +656,14 @@ Examine your Detox config${this._atPath()}`,
   }
 
   invalidTestRunnerProperty(isGlobal) {
+    const testRunner = _.get(this.contents, ['testRunner']);
+
     return new DetoxConfigError({
-      message: `testRunner should be an object, not a string`,
+      message: `testRunner should be an object, not a ${typeof testRunner}`,
       hint: `Check that in your Detox config${this._atPath()}`,
       inspectOptions: { depth: isGlobal ? 0 : 3 },
       debugInfo: isGlobal ? {
-        testRunner: _.get(this.contents, ['testRunner']),
+        testRunner,
         ...this.contents,
       } : {
         ...this._focusOnConfiguration(c => _.pick(c, ['testRunner'])),

package/src/ipc/IPCClient.js

@@ -53,9 +53,10 @@ class IPCClient {
 
   /**
    * @param {string[]} testFilePaths
+   * @param {Boolean} permanent
    */
-  async reportFailedTests(testFilePaths) {
-    await this._emit('failedTests', { testFilePaths });
+  async reportFailedTests(testFilePaths, permanent) {
+    await this._emit('failedTests', { testFilePaths, permanent });
   }
 
   async _connectToServer() {

package/src/ipc/IPCServer.js

@@ -55,7 +55,11 @@ class IPCServer {
       this._sessionState.logFiles.push(logFile);
     }
 
-    this._ipc.server.emit(socket, 'registerContextDone', {});
+    this._ipc.server.emit(socket, 'registerContextDone', {
+      failedTestFiles: this._sessionState.failedTestFiles,
+      testFilesToRetry: this._sessionState.testFilesToRetry,
+      testSessionIndex: this._sessionState.testSessionIndex,
+    });
   }
 
   onRegisterWorker({ workerId }, socket) {
@@ -69,12 +73,21 @@ class IPCServer {
     }
   }
 
-  onFailedTests({ testFilePaths }, socket) {
-    this._sessionState.failedTestFiles.push(...testFilePaths);
+  onFailedTests({ testFilePaths, permanent }, socket = null) {
+    if (permanent) {
+      this._sessionState.failedTestFiles.push(...testFilePaths);
+    } else {
+      this._sessionState.testFilesToRetry.push(...testFilePaths);
+    }
 
     if (socket) {
       this._ipc.server.emit(socket, 'failedTestsDone', {});
     }
+
+    this._ipc.server.broadcast('sessionStateUpdate', {
+      failedTestFiles: this._sessionState.failedTestFiles,
+      testFilesToRetry: this._sessionState.testFilesToRetry,
+    });
   }
 }
 

package/src/ipc/state.js

@@ -38,25 +38,47 @@ class SessionState {
 }
 
 class SecondarySessionState extends SessionState {
-  constructor({ id = uuid.UUID(), detoxConfigSnapshotPath = '', detoxConfig = null, detoxIPCServer = '', workerId = undefined, workersCount = 0 }) {
+  constructor({
+    id = uuid.UUID(),
+    detoxConfigSnapshotPath = '',
+    detoxConfig = null,
+    detoxIPCServer = '',
+    failedTestFiles = [],
+    testFilesToRetry = [],
+    testSessionIndex = 0,
+    workerId = undefined,
+    workersCount = 0
+  }) {
     super();
 
     this.id = id;
     this.detoxConfigSnapshotPath = detoxConfigSnapshotPath;
     this.detoxConfig = detoxConfig;
     this.detoxIPCServer = detoxIPCServer;
+    this.failedTestFiles = failedTestFiles;
+    this.testFilesToRetry = testFilesToRetry;
+    this.testSessionIndex = testSessionIndex;
     this.workerId = workerId;
     this.workersCount = workersCount;
   }
 }
 
 class PrimarySessionState extends SecondarySessionState {
-  constructor({ contexts = [], failedTestFiles = [], logFiles = [], ...baseOpts }) {
+  constructor({
+    contexts = [],
+    logFiles = [],
+    failedTestFiles = [],
+    testFilesToRetry = [],
+    testSessionIndex = 0,
+    ...baseOpts
+  }) {
     super(baseOpts);
 
     this.contexts = contexts;
     this.failedTestFiles = failedTestFiles;
     this.logFiles = logFiles;
+    this.testSessionIndex = testSessionIndex;
+    this.testFilesToRetry = testFilesToRetry;
   }
 }
 

package/src/realms/DetoxContext.js

@@ -19,7 +19,7 @@ class DetoxContext {
   constructor() {
     this[symbols.globalSetup] = this[symbols.globalSetup].bind(this);
     this[symbols.globalTeardown] = this[symbols.globalTeardown].bind(this);
-    this[symbols.reportFailedTests] = this[symbols.globalTeardown].bind(this);
+    this[symbols.reportFailedTests] = this[symbols.reportFailedTests].bind(this);
     this[symbols.resolveConfig] = this[symbols.resolveConfig].bind(this);
     this[symbols.setup] = this[symbols.setup].bind(this);
     this[symbols.teardown] = this[symbols.teardown].bind(this);
@@ -27,7 +27,7 @@ class DetoxContext {
     this[$sessionState] = this[$restoreSessionState]();
 
     const loggerConfig = this[$sessionState].detoxConfig
-      ? this[$sessionState].detoxConfig.loggerConfig
+      ? this[$sessionState].detoxConfig.logger
       : undefined;
 
     /**
@@ -93,7 +93,7 @@ class DetoxContext {
   [symbols.config] = funpermaproxy(() => this[symbols.session].detoxConfig);
   [symbols.session] = funpermaproxy(() => this[$sessionState]);
   /** @abstract */
-  [symbols.reportFailedTests](_testFilePaths) {}
+  [symbols.reportFailedTests](_testFilePaths, _permanent) {}
   /**
    * @abstract
    * @param {Partial<DetoxInternals.DetoxGlobalSetupOptions>} _opts

package/src/realms/DetoxPrimaryContext.js

@@ -34,9 +34,9 @@ class DetoxPrimaryContext extends DetoxContext {
   }
 
   //#region Internal members
-  async [symbols.reportFailedTests](testFilePaths) {
+  async [symbols.reportFailedTests](testFilePaths, permanent = false) {
     if (this[_ipcServer]) {
-      this[_ipcServer].onFailedTests({ testFilePaths });
+      this[_ipcServer].onFailedTests({ testFilePaths, permanent });
     }
   }
 
@@ -65,7 +65,12 @@ class DetoxPrimaryContext extends DetoxContext {
     this[_dirty] = true;
     const detoxConfig = await this[symbols.resolveConfig](opts);
 
-    const { behaviorConfig, deviceConfig, loggerConfig, sessionConfig } = detoxConfig;
+    const {
+      behavior: behaviorConfig,
+      device: deviceConfig,
+      logger: loggerConfig,
+      session: sessionConfig
+    } = detoxConfig;
     await this[$logger].setConfig(loggerConfig);
 
     this.trace.begin({
@@ -120,8 +125,9 @@ class DetoxPrimaryContext extends DetoxContext {
    * @param {Partial<DetoxInternals.DetoxConfigurationSetupOptions>} [opts]
    */
   async [symbols.setup](opts) {
-    this[$sessionState].workerId = opts.workerId;
-    this[_ipcServer].onRegisterWorker({ workerId: opts.workerId });
+    const workerId = opts.workerId || 1;
+    this[$sessionState].workerId = workerId;
+    this[_ipcServer].onRegisterWorker({ workerId });
     await super[symbols.setup](opts);
   }
 
@@ -176,7 +182,7 @@ class DetoxPrimaryContext extends DetoxContext {
     }
 
     const streamUtils = require('../utils/streamUtils');
-    const { rootDir, plugins } = this[symbols.config].artifactsConfig || {};
+    const { rootDir, plugins } = this[symbols.config].artifacts || {};
     const logConfig = plugins && plugins.log || 'none';
     const enabled = rootDir && (typeof logConfig === 'string' ? logConfig !== 'none' : logConfig.enabled);
 
@@ -203,7 +209,7 @@ class DetoxPrimaryContext extends DetoxContext {
   async[_resetLockFile]() {
     const DeviceRegistry = require('../devices/DeviceRegistry');
 
-    const deviceType = this[symbols.config].deviceConfig.type;
+    const deviceType = this[symbols.config].device.type;
 
     switch (deviceType) {
       case 'ios.none':

package/src/realms/DetoxSecondaryContext.js

@@ -21,9 +21,9 @@ class DetoxSecondaryContext extends DetoxContext {
   }
 
   //#region Internal members
-  async [symbols.reportFailedTests](testFilePaths) {
+  async [symbols.reportFailedTests](testFilePaths, permanent = false) {
     if (this[_ipcClient]) {
-      await this[_ipcClient].reportFailedTests(testFilePaths);
+      await this[_ipcClient].reportFailedTests(testFilePaths, permanent);
     } else {
       throw new DetoxInternalError('Detected an attempt to report failed tests using a non-initialized context.');
     }
@@ -59,8 +59,9 @@ class DetoxSecondaryContext extends DetoxContext {
       logger: this[$logger],
     });
 
+    const workerId = opts.workerId || 1;
     await this[_ipcClient].init();
-    await this[_ipcClient].registerWorker(opts.workerId);
+    await this[_ipcClient].registerWorker(workerId);
     await super[symbols.setup](opts);
   }