detox 20.0.10-prerelease.0 → 20.0.12-prerelease.0

package/local-cli/test.test.js

@@ -8,6 +8,8 @@ jest.mock('../src/devices/DeviceRegistry');
 jest.mock('../src/devices/allocation/drivers/android/genycloud/GenyDeviceRegistryFactory');
 jest.mock('./utils/jestInternals');
 
+const cp = require('child_process');
+const cpSpawn = cp.spawn;
 const os = require('os');
 const path = require('path');
 
@@ -28,6 +30,10 @@ describe('CLI', () => {
   let GenyDeviceRegistryFactory;
   let jestInternals;
 
+  afterEach(() => {
+    cp.spawn = cpSpawn;
+  });
+
   beforeEach(() => {
     _cliCallDump = undefined;
     _env = process.env;
@@ -139,11 +145,28 @@ describe('CLI', () => {
   });
 
   test.each([['-R'], ['--retries']])('%s <value> should execute unsuccessful run N extra times', async (__retries) => {
+    function toTestResult(testFilePath) {
+      return {
+        testFilePath,
+        success: false,
+        isPermanentFailure: false,
+      };
+    }
+
     const context = require('../internals');
-    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']);
+
+    jest.spyOn(cp, 'spawn')
+      .mockImplementationOnce((...args) => {
+        context.session.testResults = ['e2e/failing1.test.js', 'e2e/failing2.test.js'].map(toTestResult);
+        return cpSpawn(...args);
+      })
+      .mockImplementationOnce((...args) => {
+        context.session.testResults = ['e2e/failing2.test.js'].map(toTestResult);
+        return cpSpawn(...args);
+      })
+      .mockImplementationOnce((...args) => {
+        return cpSpawn(...args);
+      });
 
     mockExitCode(1);
 
@@ -154,18 +177,35 @@ describe('CLI', () => {
     expect(cliCall(2).argv).toEqual([expect.stringMatching(/executable$/), '--config', 'e2e/config.json', 'e2e/failing2.test.js']);
   });
 
-  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'];
+  describe('when there are permanently failed tests', () => {
+    beforeEach(() => {
+      const context = require('../internals');
+      context.session.testResults = ['e2e/failing1.test.js', 'e2e/failing2.test.js'].map((testFilePath, index) => ({
+        testFilePath,
+        success: false,
+        isPermanentFailure: index > 0,
+      }));
 
-    mockExitCode(1);
+      mockExitCode(1);
+    });
 
-    await run(__retries, 2).catch(_.noop);
+    test.each([['-R'], ['--retries']])('%s <value> should not bail by default', async (__retries) => {
+      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);
+      expect(cliCall(0).env).not.toHaveProperty('DETOX_RERUN_INDEX');
+      expect(cliCall(0).argv).toEqual([expect.stringMatching(/executable$/), '--config', 'e2e/config.json']);
+      expect(cliCall(1).argv).toEqual([expect.stringMatching(/executable$/), '--config', 'e2e/config.json', 'e2e/failing1.test.js']);
+      // note that it does not take the permanently failed test
+    });
+
+    test.each([['-R'], ['--retries']])('%s <value> should bail if configured', async (__retries) => {
+      detoxConfig.testRunner.bail = true;
+      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) => {
@@ -178,7 +218,11 @@ describe('CLI', () => {
 
   test.each([['-R'], ['--retries']])('%s <value> should retain -- <...explicitPassthroughArgs>', async (__retries) => {
     const context = require('../internals');
-    context.session.testFilesToRetry = ['tests/failing.test.js'];
+    context.session.testResults = [{
+      testFilePath: 'tests/failing.test.js',
+      success: false,
+      isPermanentFailure: false,
+    }];
 
     mockExitCode(1);
 

package/local-cli/testCommand/TestRunnerCommand.js

@@ -99,13 +99,20 @@ class TestRunnerCommand {
       } catch (e) {
         launchError = e;
 
-        const { failedTestFiles, testFilesToRetry } = detox.session;
-        if (!_.isEmpty(failedTestFiles) || _.isEmpty(testFilesToRetry)) {
+        const failedTestFiles = detox.session.testResults.filter(r => !r.success);
+
+        const { bail } = detox.config.testRunner;
+        if (bail && failedTestFiles.some(r => r.isPermanentFailure)) {
+          throw e;
+        }
+
+        const testFilesToRetry = failedTestFiles.filter(r => !r.isPermanentFailure).map(r => r.testFilePath);
+        if (_.isEmpty(testFilesToRetry)) {
           throw e;
         }
 
         if (--runsLeft > 0) {
-          this._argv._ = testFilesToRetry.splice(0, Infinity);
+          this._argv._ = testFilesToRetry;
           // @ts-ignore
           detox.session.testSessionIndex++; // it is always a primary context, so we can update it
         }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "detox",
   "description": "E2E tests and automation for mobile",
-  "version": "20.0.10-prerelease.0",
+  "version": "20.0.12-prerelease.0",
   "bin": {
     "detox": "local-cli/cli.js"
   },
@@ -184,5 +184,5 @@
       }
     }
   },
-  "gitHead": "3116a188b0e4d57613dc2f7d26ca80292b74f192"
+  "gitHead": "3cd7feb90f69058ec124fa085cdacc8d167161a7"
 }

package/runners/deprecation.js

@@ -4,7 +4,7 @@ const chalk = require('chalk');
 console.error(chalk.yellow(`
 =========================  THE NEW JOURNEY BEGINS  =============================
 
-        https://github.com/wix/Detox/blob/master/docs/Guide.Jest.md
+            https://wix.github.io/Detox/docs/next/guide/migration
 
              _.-;-._              Sorry, traveler from the lands of Detox 19!
             ;_.JL___;
@@ -36,7 +36,7 @@ console.error(chalk.yellow(`
 snd   ||   '---'    '.___>
 Credit: "Gimli" by Shanaka Dias
 
-        https://github.com/wix/Detox/blob/master/docs/Guide.Jest.md
+            https://wix.github.io/Detox/docs/next/guide/migration
 
 =========================  THE NEW JOURNEY BEGINS  =============================
 

package/runners/jest/reporters/DetoxReporter.js

@@ -1,5 +1,25 @@
-const { VerboseReporter: JestVerboseReporter } = require('@jest/reporters'); // eslint-disable-line node/no-extraneous-require
+const resolveFrom = require('resolve-from');
+/** @type {typeof import('@jest/reporters').VerboseReporter} */
+const JestVerboseReporter = require(resolveFrom(process.cwd(), '@jest/reporters')).VerboseReporter;
 
-class DetoxReporter extends JestVerboseReporter {}
+const { config, reportTestResults } = require('../../../internals');
+
+class DetoxReporter extends JestVerboseReporter {
+  /**
+   * @param {import('@jest/test-result').TestResult} testResult
+   */
+  async onTestResult(test, testResult, results) {
+    await super.onTestResult(test, testResult, results);
+
+    await reportTestResults([{
+      success: !testResult.failureMessage,
+      testFilePath: testResult.testFilePath,
+      testExecError: testResult.testExecError,
+      isPermanentFailure: config.testRunner.jest.retryAfterCircusRetries
+        ? false
+        : testResult.testResults.some(r => r.invocations > 1)
+    }]);
+  }
+}
 
 module.exports = DetoxReporter;

package/runners/jest/testEnvironment/index.js

@@ -1,6 +1,6 @@
 const resolveFrom = require('resolve-from');
 const maybeNodeEnvironment = require(resolveFrom(process.cwd(), 'jest-environment-node'));
-// @ts-ignore
+/** @type {typeof import('@jest/environment').JestEnvironment} */
 const NodeEnvironment = maybeNodeEnvironment.default || maybeNodeEnvironment;
 
 const detox = require('../../../internals');
@@ -33,110 +33,98 @@ class DetoxCircusEnvironment extends NodeEnvironment {
   constructor(config, context) {
     super(assertJestCircus27(config), assertExistingContext(context));
 
-    /** @private */
-    this._timer = null;
-    /** @private */
-    this._listenerFactories = {
-      DetoxInitErrorListener,
-      DetoxPlatformFilterListener,
-      DetoxCoreListener,
-      SpecReporter,
-      WorkerAssignReporter,
-    };
     /** @private */
     this._shouldManageDetox = detox.getStatus() === 'inactive';
     /** @private */
-    this._setupFailed = false;
+    this._timer = new Timer();
+
     /** @internal */
     this.testPath = context.testPath;
     /** @protected */
     this.testEventListeners = [];
     /** @protected */
-    this.initTimeout = detox.config.testRunner.jest.initTimeout;
-    /** @internal */
+    this.setupTimeout = detox.config.testRunner.jest.setupTimeout;
+    /** @protected */
+    this.teardownTimeout = detox.config.testRunner.jest.teardownTimeout;
+
     log.trace.begin(this.testPath);
 
-    this.setup = log.trace.complete.bind(null, 'set up environment', this.setup.bind(this));
+    const _setup = this.setup.bind(this);
+    this.setup = async () => {
+      await log.trace.complete('set up environment', async () => {
+        try {
+          this._timer.schedule(this.setupTimeout);
+          await this._handleTestEventAsync({ name: 'environment_setup_start' });
+          await this._timer.run(`setting up Detox environment`, _setup);
+          await this._handleTestEventAsync({ name: 'environment_setup_success' });
+        } catch (error) {
+          this._timer.schedule(this.teardownTimeout);
+          await this._handleTestEventAsync({ name: 'environment_setup_failure', error });
+          throw error;
+        } finally {
+          this._timer.clear();
+        }
+      });
+    };
+
     const _teardown = this.teardown.bind(this);
     this.teardown = async () => {
-      try {
-        await log.trace.complete('tear down environment', _teardown);
-      } finally {
-        await log.trace.end();
-      }
+      await log.trace.complete('tear down environment', async () => {
+        try {
+          this._timer.schedule(this.teardownTimeout);
+          await this._handleTestEventAsync({ name: 'environment_teardown_start' });
+          await this._timer.run(`tearing down Detox environment`, _teardown);
+          await this._handleTestEventAsync({ name: 'environment_teardown_success' });
+        } catch (error) {
+          if (this._timer.expired) {
+            this._timer.schedule(this.teardownTimeout);
+          }
+
+          await this._handleTestEventAsync({ name: 'environment_teardown_failure', error });
+          throw error;
+        } finally {
+          this._timer.clear();
+          log.trace.end();
+        }
+      });
     };
+
+    this.registerListeners({
+      DetoxInitErrorListener,
+      DetoxPlatformFilterListener,
+      DetoxCoreListener,
+      SpecReporter,
+      WorkerAssignReporter,
+    });
   }
 
   /** @override */
   async setup() {
-    try {
-      await super.setup();
-      await Timer.run({
-        description: `setting up Detox environment`,
-        timeout: this.initTimeout,
-        fn: async () => {
-          await this.initDetox();
-          this._instantiateListeners();
-        },
-      });
-    } catch (e) {
-      this._setupFailed = true;
-      throw e;
-    }
+    await this.initDetox();
   }
 
-  /** @override */
-  async handleTestEvent(event, state) {
-    const { name } = event;
+  handleTestEvent = async (event, state) => {
+    this._timer.schedule(state.testTimeout != null ? state.testTimeout : this.setupTimeout);
 
-    if (SYNC_CIRCUS_EVENTS.has(name)) {
-      return this._handleTestEventSync(event, state);
-    }
-
-    this._timer = new Timer({
-      description: `handling jest-circus "${name}" event`,
-      timeout: state.testTimeout != null ? state.testTimeout : this.initTimeout,
-    });
-
-    try {
-      for (const listener of this.testEventListeners) {
-        if (typeof listener[name] !== 'function') {
-          continue;
-        }
-
-        try {
-          await this._timer.run(() => listener[name](event, state));
-        } catch (listenerError) {
-          log.error(listenerError);
-          break;
-        }
-      }
-    } finally {
-      this._timer.dispose();
-      this._timer = null;
+    if (SYNC_CIRCUS_EVENTS.has(event.name)) {
+      this._handleTestEventSync(event, state);
+    } else {
+      await this._handleTestEventAsync(event, state);
     }
-  }
+  };
 
   /** @override */
   async teardown() {
-    await Timer.run({
-      description: `tearing down Detox environment`,
-      timeout: this.initTimeout,
-      fn: async () => {
-        try {
-          if (this._setupFailed) {
-            await detox.reportFailedTests([this.testPath], false);
-          }
-        } finally {
-          await this.cleanupDetox();
-        }
-      },
-    });
+    await this.cleanupDetox();
   }
 
   /** @protected */
   registerListeners(map) {
-    Object.assign(this._listenerFactories, map);
+    for (const Listener of Object.values(map)) {
+      this.testEventListeners.push(new Listener({
+        env: this,
+      }));
+    }
   }
 
   /**
@@ -153,6 +141,8 @@ class DetoxCircusEnvironment extends NodeEnvironment {
     } else {
       await detox.installWorker(opts);
     }
+
+    return detox.worker;
   }
 
   /** @protected */
@@ -176,11 +166,22 @@ class DetoxCircusEnvironment extends NodeEnvironment {
   }
 
   /** @private */
-  _instantiateListeners() {
-    for (const Listener of Object.values(this._listenerFactories)) {
-      this.testEventListeners.push(new Listener({
-        env: this,
-      }));
+  async _handleTestEventAsync(event, state = null) {
+    const description = `handling ${state ? 'jest-circus' : 'jest-environment'} "${event.name}" event`;
+
+    for (const listener of this.testEventListeners) {
+      if (typeof listener[event.name] !== 'function') {
+        continue;
+      }
+
+      try {
+        await this._timer.run(description, () => listener[event.name](event, state));
+      } catch (listenerError) {
+        log.error(listenerError);
+        if (this._timer.expired) {
+          break;
+        }
+      }
     }
   }
 }

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

@@ -14,7 +14,7 @@ class DetoxCoreListener {
     this._startedTests = new WeakSet();
     this._testsFailedBeforeStart = new WeakSet();
     this._env = env;
-    this._testRunTimes = 1;
+    this._circusRetryTimes = 1;
   }
 
   async setup() {
@@ -46,7 +46,7 @@ class DetoxCoreListener {
     }
 
     const circusRetryTimes = +this._env.global[RETRY_TIMES];
-    this._testRunTimes = isNaN(circusRetryTimes) ? 1 : 1 + circusRetryTimes;
+    this._circusRetryTimes = isNaN(circusRetryTimes) ? 1 : 1 + circusRetryTimes;
   }
 
   async hook_start(event, state) {
@@ -58,7 +58,12 @@ class DetoxCoreListener {
     log.trace.end({ success: true });
   }
 
-  async hook_failure({ error }) {
+  async hook_failure({ error, hook }) {
+    await detoxInternals.onHookFailure({
+      error,
+      hook: hook.type,
+    });
+
     log.trace.end({ success: false, error });
   }
 
@@ -94,14 +99,6 @@ class DetoxCoreListener {
     }
   }
 
-  async run_finish(_event, state) {
-    const hasFailedTests = this._hasFailedTests(state.rootDescribeBlock);
-    if (hasFailedTests) {
-      const handledByJestCircus = this._testRunTimes > 1 && !detoxInternals.config.testRunner.jest.retryAfterCircusRetries;
-      await detoxInternals.reportFailedTests([this._env.testPath], handledByJestCircus);
-    }
-  }
-
   async _onBeforeActualTestStart(test) {
     if (!test || test.status === 'skip' || this._startedTests.has(test) || this._testsFailedBeforeStart.has(test)) {
       return false;
@@ -127,19 +124,7 @@ class DetoxCoreListener {
 
   _getTestInvocations(test) {
     const { testSessionIndex } = detoxInternals.session;
-    return testSessionIndex * this._testRunTimes + test.invocations;
-  }
-
-  _hasFailedTests(block) {
-    if (block.children) {
-      for (const child of block.children) {
-        if (this._hasFailedTests(child)) {
-          return true;
-        }
-      }
-    }
-
-    return block.errors ? block.errors.length > 0 : false;
+    return testSessionIndex * this._circusRetryTimes + test.invocations;
   }
 
   _getTestMetadata(test) {

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

@@ -5,7 +5,7 @@ const { device } = require('../../../..');
 const PLATFORM_REGEXP = /^:([^:]+):/;
 
 class DetoxPlatformFilterListener {
-  constructor() {
+  setup() {
     this._platform = device.getPlatform();
   }
 

package/src/client/actions/formatters/sync-resources/NetworkFormatter.js

@@ -1,7 +1,7 @@
 const { makeResourceTitle, makeResourceSubTitle } = require('./utils');
 
 function makeURLDescription(url, urlCount) {
-  return makeResourceSubTitle(`URL #${urlCount}: ${url}.`);
+  return makeResourceSubTitle(`URL #${urlCount}: ${url}`);
 }
 
 module.exports = function(properties) {

package/src/configuration/composeAppsConfig.js

@@ -144,6 +144,10 @@ function validateAppConfig({ appConfig, appPath, deviceConfig, errorComposer })
   if (appConfig.launchArgs && !_.isObject(appConfig.launchArgs)) {
     throw errorComposer.malformedAppLaunchArgs(appPath);
   }
+
+  if (appConfig.type !== 'android.apk' && appConfig.reversePorts) {
+    throw errorComposer.unsupportedReversePorts(appPath);
+  }
 }
 
 module.exports = composeAppsConfig;

package/src/configuration/composeRunnerConfig.js

@@ -32,8 +32,10 @@ function composeRunnerConfig(opts) {
       retries: 0,
       inspectBrk: inspectBrkHookDefault,
       forwardEnv: false,
+      bail: false,
       jest: {
-        initTimeout: 300000,
+        setupTimeout: 300000,
+        teardownTimeout: 30000,
         retryAfterCircusRetries: false,
         reportSpecs: undefined,
         reportWorkerAssign: true,
@@ -88,7 +90,7 @@ function adaptLegacyRunnerConfig(globalConfig) {
     return globalConfig.testRunner;
   }
 
-  log.warn(`Please migrate your Detox config according to the guide: [TODO: insert the migration guilde link]`);
+  log.warn(`Please migrate your Detox config according to the guide:\nhttps://wix.github.io/Detox/docs/next/guide/migration\n`);
   const testRunner = globalConfig[testRunnerKey];
   const runnerConfig = globalConfig[runnerConfigKey];
   const specs = globalConfig.specs != null ? String(globalConfig.specs) : undefined;

package/src/devices/allocation/drivers/android/emulator/AVDValidator.js

@@ -12,11 +12,11 @@ class AVDValidator {
     this._emulatorVersionResolver = emulatorVersionResolver;
   }
 
-  async validate(avdName) {
+  async validate(avdName, isHeadless) {
     const avds = await this._avdsResolver.resolve(avdName);
     this._assertAVDs(avds);
     await this._assertAVDMatch(avds, avdName);
-    await this._validateEmulatorVer();
+    await this._validateEmulatorVer(isHeadless);
   }
 
   _assertAVDs(avds) {
@@ -37,8 +37,8 @@ class AVDValidator {
     }
   }
 
-  async _validateEmulatorVer() {
-    const emulatorVersion = await this._emulatorVersionResolver.resolve();
+  async _validateEmulatorVer(isHeadless) {
+    const emulatorVersion = await this._emulatorVersionResolver.resolve(isHeadless);
     if (!emulatorVersion) {
       logger.warn({ event: 'AVD_VALIDATION' }, 'Emulator version detection failed (See previous logs)');
       return;

package/src/devices/allocation/drivers/android/emulator/EmulatorAllocDriver.js

@@ -34,7 +34,7 @@ class EmulatorAllocDriver extends AllocationDriverBase {
   async allocate(deviceConfig) {
     const avdName = deviceConfig.device.avdName;
 
-    await this._avdValidator.validate(avdName);
+    await this._avdValidator.validate(avdName, deviceConfig.headless);
     await this._fixAvdConfigIniSkinNameIfNeeded(avdName, deviceConfig.headless);
 
     const allocResult = await this._allocationHelper.allocateDevice(avdName);

package/src/devices/common/drivers/ios/tools/AppleSimUtils.js

@@ -157,6 +157,30 @@ class AppleSimUtils {
   }
 
   async sendToHome(udid) {
+    if (await this._isSpringBoardInaccessible(udid)) {
+      // SpringBoard is not directly accessible by Simctl on iOS 16.0 and above, therefore we launch and terminate the
+      // Settings app instead. This sends the currently open app to the background and brings the home screen to the
+      // foreground.
+      await this._launchAndTerminateSettings(udid);
+      return;
+    }
+
+    await this._launchSpringBoard(udid);
+  }
+
+  async _isSpringBoardInaccessible(udid) {
+    const device = await this._findDeviceByUDID(udid);
+    const majorIOSVersion = parseInt(device.os.version.split('.')[0]);
+    return majorIOSVersion >= 16;
+  }
+
+  async _launchAndTerminateSettings(udid) {
+    const bundleId = 'com.apple.Preferences';
+    await this._execSimctl({ cmd: `launch ${udid} ${bundleId}`, retries: 10 });
+    await this._execSimctl({ cmd: `terminate ${udid} ${bundleId}`, retries: 10 });
+  }
+
+  async _launchSpringBoard(udid) {
     await this._execSimctl({ cmd: `launch ${udid} com.apple.springboard`, retries: 10 });
   }
 
@@ -271,7 +295,7 @@ class AppleSimUtils {
       // ```
       // This workaround is done to ignore the error above, as we do not care if the app was running before, we just
       // want to make sure it isn't now.
-      if (err.code === 3 && 
+      if (err.code === 3 &&
           (err.stderr.includes(`the app is not currently running`) ||
            err.stderr.includes(`The operation couldn’t be completed. found nothing to terminate`))) {
         return;

package/src/devices/lifecycle/GenyGlobalLifecycleHandler.js

@@ -30,7 +30,7 @@ class GenyGlobalLifecycleHandler {
 }
 
 async function doSafeCleanup(instanceLifecycleService, instanceHandles) {
-  logger.info(cleanupLogData, 'Initiating Genymotion cloud instances teardown...');
+  logger.info(cleanupLogData, 'Initiating Genymotion SaaS instances teardown...');
 
   const deletionLeaks = [];
   const killPromises = instanceHandles.map((instanceHandle) =>
@@ -43,7 +43,7 @@ async function doSafeCleanup(instanceLifecycleService, instanceHandles) {
 
 function reportGlobalCleanupSummary(deletionLeaks) {
   if (deletionLeaks.length) {
-    logger.warn(cleanupLogData, 'WARNING! Detected a Genymotion cloud instance leakage, for the following instances:');
+    logger.warn(cleanupLogData, 'WARNING! Detected a Genymotion SaaS instance leakage, for the following instances:');
 
     deletionLeaks.forEach(({ uuid, name, error }) => {
       logger.warn(cleanupLogData, [

package/src/devices/runtime/RuntimeDevice.js

@@ -238,6 +238,16 @@ class RuntimeDevice {
   async installApp(binaryPath, testBinaryPath) {
     const currentApp = binaryPath ? { binaryPath, testBinaryPath } : this._getCurrentApp();
     await this.deviceDriver.installApp(currentApp.binaryPath, currentApp.testBinaryPath);
+
+    // This abstraction leaks because our drivers themselves leak,
+    // so don't blame me - DeviceBaseDriver itself has `reverseTcpPort`,
+    // setting a vicious downward spiral. I can't refactor everything
+    // in a single pull request, so let's bear with it for now.
+    if (Array.isArray(currentApp.reversePorts)) {
+      for (const port of currentApp.reversePorts) {
+        await this.reverseTcpPort(port);
+      }
+    }
   }
 
   async uninstallApp(bundleId) {

package/src/errors/DetoxConfigErrorComposer.js

@@ -507,6 +507,14 @@ Examine your Detox config${this._atPath()}`,
     });
   }
 
+  unsupportedReversePorts(appPath) {
+    return new DetoxConfigError({
+      message: `Non-Android app configs cannot have "reversePorts" property:`,
+      debugInfo: this._focusOnAppConfig(appPath),
+      inspectOptions: { depth: 4 },
+    });
+  }
+
   missingAppBinaryPath(appPath) {
     return new DetoxConfigError({
       message: `Missing "binaryPath" property in the app config.\nExpected a string:`,