detox 20.12.1 → 20.13.0

package/runners/jest/reporters/DetoxReporter.js

@@ -1,24 +1,142 @@
 const resolveFrom = require('resolve-from');
-/** @type {typeof import('@jest/reporters').VerboseReporter} */
+/** @type {new (globalConfig: any) => import('@jest/reporters').VerboseReporter} */
 const JestVerboseReporter = require(resolveFrom(process.cwd(), '@jest/reporters')).VerboseReporter;
+/** @type {new (globalConfig: any) => import('@jest/reporters').SummaryReporter} */
+const SummaryReporter = require(resolveFrom(process.cwd(), '@jest/reporters')).SummaryReporter;
 
-const { config, reportTestResults } = require('../../../internals');
+const { config, reportTestResults, unsafe_conductEarlyTeardown, cleanup } = require('../../../internals');
+const Deferred = require('../../../src/utils/Deferred');
 
 class DetoxReporter extends JestVerboseReporter {
+  constructor(globalConfig) {
+    super(globalConfig);
+
+    /** @type {Deferred | null} */
+    this._lastRunComplete = null;
+    /** @type {Set<string>} */
+    this._pendingTestFiles = new Set();
+    /** @type {Promise<any> | null} */
+    this._runCompletePromise = null;
+    /** @type {import('@jest/reporters').SummaryReporter | null} */
+    this._summaryReporter = this._initSummaryReporter();
+  }
+
+  onRunStart(aggregatedResults, options) {
+    super.onRunStart(aggregatedResults, options);
+
+    if (this._summaryReporter) {
+      this._summaryReporter.onRunStart(aggregatedResults, options);
+    }
+  }
+
+  onTestFileStart(test) {
+    this._pendingTestFiles.add(test.path);
+
+    // @ts-ignore Precaution in case Jest migrates to the new signature
+    if (typeof super.onTestFileStart === 'function') {
+      // @ts-ignore
+      super.onTestFileStart(test);
+    } else {
+      super.onTestStart(test);
+    }
+  }
+
+  onTestFileResult(test, testResult, aggregatedResult) {
+    this._pendingTestFiles.delete(test.path);
+
+    // @ts-ignore Precaution in case Jest migrates to the new signature
+    if (typeof super.onTestFileResult === 'function') {
+      // @ts-ignore
+      super.onTestFileResult(test, testResult, aggregatedResult);
+    } else {
+      super.onTestResult(test, testResult, aggregatedResult);
+    }
+
+    if (this._lastRunComplete && this._pendingTestFiles.size === 0) {
+      this._lastRunComplete.resolve(aggregatedResult);
+    }
+  }
+
   /**
-   * @param {import('@jest/test-result').AggregatedResult} results
+   * @param {Set<import('@jest/reporters').TestContext>} testContexts
+   * @param {import('@jest/reporters').AggregatedResult} aggregatedResult
+   * @returns {Promise<any> | null}
    */
-  // @ts-ignore
-  async onRunComplete(_contexts, results) {
-    // @ts-ignore
-    await super.onRunComplete(_contexts, results);
+  // @ts-ignore We need to use the complete signature, not the one from the base class
+  onRunComplete(testContexts, aggregatedResult) {
+    if (!this._runCompletePromise) {
+      // Both `_lastRunComplete` and `_runCompletePromise` are used to prevent
+      // a bug in Jest, where `onRunComplete` is called multiple times when
+      // Jest runs with `--bail` and multiple workers, and `onRunComplete`
+      // is implemented as an asynchronous long-running operation.
+      this._lastRunComplete = this._pendingTestFiles.size === 0
+        ? Deferred.resolved(aggregatedResult)
+        : new Deferred();
 
-    await reportTestResults(results.testResults.map(r => ({
+      this._runCompletePromise = this._onRunComplete(testContexts, aggregatedResult).catch(err => {
+        console.error(err);
+        throw err;
+      });
+    }
+
+    return this._runCompletePromise;
+  }
+
+  /**
+   * @param {Set<import('@jest/reporters').TestContext>} testContexts
+   * @param {import('@jest/reporters').AggregatedResult} aggregatedResult
+   * @returns {Promise<any> | null}
+   */
+  async _onRunComplete(testContexts, { numFailedTests }) {
+    const bail = this._globalConfig.bail;
+    const earlyTeardown = bail > 0 && numFailedTests >= bail;
+    if (earlyTeardown) {
+      await unsafe_conductEarlyTeardown();
+    }
+
+    const aggregatedResult = await this._lastRunComplete.promise;
+    const lostTests = aggregatedResult.numTotalTestSuites - aggregatedResult.testResults.length;
+
+    // @ts-expect-error TS2554
+    super.onRunComplete(testContexts, aggregatedResult);
+
+    if (earlyTeardown && lostTests > 0 && config.testRunner.retries > 0) {
+      console.warn(
+        'Jest aborted the test execution before all scheduled test files have been reported.\n' +
+        'This brings us to a dilemma: retry the whole test run, or retry only known failed test files.\n' +
+        'Both options are bad in their own way, this is why we have decided to not support this edge case.\n' +
+        'If you want to retry the whole test run, please disable Jest\'s --bail option.'
+      );
+    }
+
+    await reportTestResults(aggregatedResult.testResults.map(r => ({
       success: !r.failureMessage,
       testFilePath: r.testFilePath,
       testExecError: r.testExecError,
-      isPermanentFailure: this._isPermanentFailure(r),
+      isPermanentFailure: lostTests > 0 || this._isPermanentFailure(r),
     })));
+
+    if (this._summaryReporter) {
+      this._summaryReporter.onRunComplete(testContexts, aggregatedResult);
+    }
+
+    if (earlyTeardown) {
+      await cleanup();
+    }
+  }
+
+  /**
+   * @returns {import('@jest/reporters').SummaryReporter | null}
+   * @private
+   */
+  _initSummaryReporter() {
+    /** @type {(config: import('@jest/types').Config.ReporterConfig) => boolean} */
+    const isSummaryReporter = (config) => config[0] === 'summary';
+    if (this._globalConfig.reporters.some(isSummaryReporter)) {
+      return null;
+    }
+
+    return new SummaryReporter(this._globalConfig);
   }
 
   /**

package/runners/jest/testEnvironment/index.js

@@ -70,7 +70,12 @@ class DetoxCircusEnvironment extends NodeEnvironment {
     await this.initDetox();
   }
 
+  // @ts-expect-error TS2425
   async handleTestEvent(event, state) {
+    if (detox.session.unsafe_earlyTeardown) {
+      throw new Error('Detox halted test execution due to an early teardown request');
+    }
+
     this._timer.schedule(state.testTimeout != null ? state.testTimeout : this.setupTimeout);
 
     if (SYNC_CIRCUS_EVENTS.has(event.name)) {

package/src/DetoxWorker.js

@@ -33,7 +33,6 @@ class DetoxWorker {
       onError: this._onEmitError.bind(this),
     });
 
-
     /** @type {DetoxInternals.RuntimeConfig['apps']} */
     this._appsConfig = null;
     /** @type {DetoxInternals.RuntimeConfig['artifacts']} */
@@ -60,7 +59,6 @@ class DetoxWorker {
     /** @type {Detox.WebFacade} */
     this.web = null;
 
-    this._deviceAllocator = null;
     this._deviceCookie = null;
 
     this.trace = this._context.trace;
@@ -115,14 +113,13 @@ class DetoxWorker {
     const {
       // @ts-ignore
       envValidatorFactory,
-      deviceAllocatorFactory,
       // @ts-ignore
       artifactsManagerFactory,
       // @ts-ignore
       matchersFactory,
       // @ts-ignore
       runtimeDeviceFactory,
-    } = environmentFactory.createFactories(this._deviceConfig);
+    } = environmentFactory.createFactories(deviceConfig);
 
     const envValidator = envValidatorFactory.createValidator();
     yield envValidator.validate();
@@ -135,10 +132,7 @@ class DetoxWorker {
     };
 
     this._artifactsManager = artifactsManagerFactory.createArtifactsManager(this._artifactsConfig, commonDeps);
-    this._deviceAllocator = deviceAllocatorFactory.createDeviceAllocator(commonDeps);
-    this._deviceCookie = yield this._deviceAllocator.allocate(this._deviceConfig);
-
-    yield this._deviceAllocator.postAllocate(this._deviceCookie);
+    this._deviceCookie = yield this._context[symbols.allocateDevice]();
 
     this.device = runtimeDeviceFactory.createRuntimeDevice(
       this._deviceCookie,
@@ -157,6 +151,8 @@ class DetoxWorker {
     });
     Object.assign(this, matchers);
 
+    yield this._eventEmitter.emit('bootDevice', { deviceId: this.device.id });
+
     if (behaviorConfig.init.exposeGlobals) {
       const injectedGlobals = {
         ...matchers,
@@ -207,11 +203,9 @@ class DetoxWorker {
     }
 
     if (this._deviceCookie) {
-      const shutdown = this._behaviorConfig ? this._behaviorConfig.cleanup.shutdownDevice : false;
-      await this._deviceAllocator.free(this._deviceCookie, { shutdown });
+      await this._context[symbols.deallocateDevice](this._deviceCookie);
     }
 
-    this._deviceAllocator = null;
     this._deviceCookie = null;
     this.device = null;
   }

package/src/artifacts/providers/index.js

@@ -4,7 +4,7 @@ class ArtifactPluginsProvider {
 
 class AndroidArtifactPluginsProvider extends ArtifactPluginsProvider {
   declareArtifactPlugins({ client }) {
-    const serviceLocator = require('../../servicelocator/android');
+    const serviceLocator = require('../../devices/servicelocator/android');
     const adb = serviceLocator.adb;
     const devicePathBuilder = serviceLocator.devicePathBuilder;
 
@@ -34,8 +34,8 @@ class IosArtifactPluginsProvider extends ArtifactPluginsProvider {
 
 class IosSimulatorArtifactPluginsProvider extends IosArtifactPluginsProvider {
   declareArtifactPlugins({ client }) {
-    const serviceLocator = require('../../servicelocator/ios');
-    const appleSimUtils = serviceLocator.appleSimUtils;
+    const AppleSimUtils = require('../../devices/common/drivers/ios/tools/AppleSimUtils');
+    const appleSimUtils = new AppleSimUtils();
 
     const SimulatorInstrumentsPlugin = require('../instruments/ios/SimulatorInstrumentsPlugin');
     const SimulatorLogPlugin = require('../log/ios/SimulatorLogPlugin');

package/src/artifacts/screenshot/SimulatorScreenshotPlugin.js

@@ -22,23 +22,6 @@ class SimulatorScreenshotPlugin extends ScreenshotArtifactPlugin {
     }
   }
 
-  async onBootDevice(event) {
-    await super.onBootDevice(event);
-
-    if (this.enabled && event.coldBoot) {
-      await this.appleSimUtils.takeScreenshot(event.deviceId, '/dev/null').catch(() => {
-        log.debug({}, `
-          NOTE: For an unknown yet reason, taking the first screenshot is apt
-          to fail when booting iOS Simulator in a hidden window mode (or on CI).
-          Detox applies a workaround by taking a dummy screenshot to ensure
-          that the future ones are going to work fine. This screenshot is not
-          saved anywhere, and the error above is suppressed for all log levels
-          except for "debug" and "trace."
-        `.trim());
-      });
-    }
-  }
-
   async onBeforeUninstallApp(event) {
     await this.api.requestIdleCallback(async () => {
       const snapshots = [

package/src/configuration/composeLoggerConfig.js

@@ -32,6 +32,7 @@ function composeLoggerConfig(opts) {
       if (!config) return acc;
       const { options } = config;
       return _.merge(acc, {
+        // @ts-ignore-line
         options: typeof options === 'function' ? options(acc) : options
       });
     },

package/src/devices/allocation/DeviceAllocator.js

@@ -1,43 +1,89 @@
-// @ts-nocheck
-const log = require('../../utils/logger').child({ cat: 'device' });
+/**
+ * @typedef {import('./drivers/AllocationDriverBase').AllocationDriverBase} AllocationDriverBase
+ * @typedef {import('./drivers/AllocationDriverBase').DeallocOptions} DeallocOptions
+ * @typedef {import('../common/drivers/DeviceCookie').DeviceCookie} DeviceCookie
+ */
+
+const log = require('../../utils/logger').child({ cat: 'device,device-allocation' });
 const traceMethods = require('../../utils/traceMethods');
 
 class DeviceAllocator {
   /**
-   * @param allocationDriver { AllocationDriverBase }
+   * @param {AllocationDriverBase} allocationDriver
    */
   constructor(allocationDriver) {
     this._driver = allocationDriver;
-    traceMethods(log, this, ['allocate', 'postAllocate', 'free']);
+    this._counter = 0;
+    this._ids = new Map();
+    traceMethods(log, this, ['init', 'cleanup', 'emergencyCleanup']);
   }
 
   /**
-   * @param deviceConfig { Object }
-   * @return {Promise<DeviceCookie>}
+   * @returns {Promise<void>}
    */
-  allocate(deviceConfig) {
-    return this._driver.allocate(deviceConfig);
+  async init() {
+    if (typeof this._driver.init === 'function') {
+      await this._driver.init();
+    }
   }
 
   /**
-   * @param {DeviceCookie} deviceCookie
-   * @return {Promise<unknown>}
+   * @param {Detox.DetoxDeviceConfig} deviceConfig
+   * @returns {Promise<DeviceCookie>}
    */
-  postAllocate(deviceCookie) {
-    if (typeof this._driver.postAllocate !== 'function') {
-      return Promise.resolve();
-    }
+  async allocate(deviceConfig) {
+    const tid = this._counter++;
+    return await log.trace.complete({ data: deviceConfig, id: tid }, 'allocate', async () => {
+      const cookie = await this._driver.allocate(deviceConfig);
+      log.debug({ data: cookie }, `settled on ${cookie.name || cookie.id}`);
+      this._ids.set(cookie.id, tid);
+      return cookie;
+    });
+  }
 
-    return this._driver.postAllocate(deviceCookie);
+  /**
+   * @param {DeviceCookie} cookie
+   * @returns {Promise<DeviceCookie>}
+   */
+  async postAllocate(cookie) {
+    const tid = this._ids.get(cookie.id);
+    return await log.trace.complete({ data: cookie, id: tid }, `post-allocate: ${cookie.id}`, async () => {
+      const updatedCookie = typeof this._driver.postAllocate === 'function'
+        ? await this._driver.postAllocate(cookie)
+        : undefined;
+
+      return updatedCookie || cookie;
+    });
   }
 
   /**
-   * @param cookie { DeviceCookie }
-   * @param options { DeallocOptions }
-   * @return {Promise<void>}
+   * @param {DeviceCookie} cookie
+   * @param {DeallocOptions} options
+   * @returns {Promise<void>}
    */
-  free(cookie, options) {
-    return this._driver.free(cookie, options);
+  async free(cookie, options = {}) {
+    const tid = this._ids.get(cookie.id);
+    await log.trace.complete({ data: options, id: tid }, `free: ${cookie.id}`, async () => {
+      await this._driver.free(cookie, options);
+    });
+  }
+
+  /**
+   * @returns {Promise<void>}
+   */
+  async cleanup() {
+    if (typeof this._driver.cleanup === 'function') {
+      await this._driver.cleanup();
+    }
+  }
+
+  /**
+   * @returns {void}
+   */
+  emergencyCleanup() {
+    if (typeof this._driver.emergencyCleanup === 'function') {
+      this._driver.emergencyCleanup();
+    }
   }
 }
 

package/src/devices/allocation/DeviceList.js

@@ -0,0 +1,44 @@
+class DeviceListReadonly {
+  constructor(devices = []) {
+    this._devices = new Map(devices.map(device => [device.id, device]));
+  }
+
+  concat(other) {
+    return new DeviceListReadonly([...this, ...other]);
+  }
+
+  getIds() {
+    return [...this._devices.keys()];
+  }
+
+  [Symbol.iterator]() {
+    return this._devices.values();
+  }
+
+  /**
+   * @param {string} deviceId
+   * @returns {boolean}
+   */
+  includes(deviceId) {
+    return this._devices.has(deviceId);
+  }
+}
+
+class DeviceList extends DeviceListReadonly {
+  filter(predicate) {
+    return new DeviceListReadonly([...this].filter(predicate));
+  }
+
+  add(deviceId, data) {
+    this._devices.set(deviceId, {
+      id: deviceId,
+      ...data,
+    });
+  }
+
+  delete(deviceId) {
+    this._devices.delete(deviceId);
+  }
+}
+
+module.exports = DeviceList;

package/src/devices/allocation/DeviceRegistry.js

@@ -0,0 +1,189 @@
+const ExclusiveLockfile = require('../../utils/ExclusiveLockfile');
+const PIDService = require('../../utils/PIDService');
+const { getDeviceRegistryPath } = require('../../utils/environment');
+const safeAsync = require('../../utils/safeAsync');
+
+const DeviceList = require('./DeviceList');
+
+const readOptions = {
+  encoding: 'utf8',
+};
+
+class DeviceRegistry {
+  constructor({
+    lockfilePath = getDeviceRegistryPath(),
+    sessionId = '',
+    pidService = new PIDService(),
+  } = {}) {
+    /***
+     * @private
+     * @type {string}
+     */
+    this._lockfilePath = lockfilePath;
+    /***
+     * @private
+     * @type {string}
+     */
+    this._sessionId = sessionId;
+    /***
+     * @private
+     */
+    this._pidService = pidService;
+    /***
+     * @protected
+     * @type {ExclusiveLockfile}
+     */
+    this._lockfile = new ExclusiveLockfile(this._lockfilePath, {
+      getInitialState: this._getInitialLockFileState.bind(this),
+      readOptions,
+    });
+  }
+
+  get lockFilePath() {
+    return this._lockfilePath;
+  }
+
+  /**
+   * Safety method to ensure that there are no remains of previously crashed Detox sessions.
+   */
+  async reset() {
+    await this._lockfile.exclusively(() => {
+      const empty = this._getInitialLockFileState();
+      this._lockfile.write(empty);
+    });
+  }
+
+  /***
+   * @param {string|Function} getDeviceId
+   * @returns {Promise<string>}
+   */
+  async registerDevice(getDeviceId) {
+    return this._lockfile.exclusively(async () => {
+      const deviceId = await safeAsync(getDeviceId);
+      if (deviceId) {
+        this._upsertDevice(deviceId, {
+          busy: true,
+          sessionId: this._sessionId,
+          pid: this._pidService.getPid(),
+        });
+      }
+      return deviceId;
+    });
+  }
+
+  /***
+   * @param {string|Function} getDeviceId
+   * @returns {Promise<string>}
+   */
+  async releaseDevice(getDeviceId) {
+    return this._lockfile.exclusively(async () => {
+      const deviceId = await safeAsync(getDeviceId);
+      if (deviceId) {
+        this._upsertDevice(deviceId, {
+          busy: false,
+          sessionId: this._sessionId,
+          pid: this._pidService.getPid(),
+        });
+      }
+      return deviceId;
+    });
+  }
+
+  /***
+   * @param {string|Function} getDeviceId
+   * @returns {Promise<void>}
+   */
+  async unregisterDevice(getDeviceId) {
+    await this._lockfile.exclusively(async () => {
+      const deviceId = await safeAsync(getDeviceId);
+      if (deviceId) {
+        this._deleteDevice(deviceId);
+      }
+    });
+  }
+
+  async unregisterSessionDevices() {
+    await this._lockfile.exclusively(async () => {
+      const allDevices = this._getRegisteredDevices();
+      const sessionDevices = allDevices.filter(device => device.sessionId === this._sessionId);
+      for (const id of sessionDevices.getIds()) {
+        allDevices.delete(id);
+      }
+      this._lockfile.write([...allDevices]);
+    });
+  }
+
+  async unregisterZombieDevices() {
+    await this._lockfile.exclusively(async () => {
+      const allDevices = this._getRegisteredDevices();
+      const zombieDevices = allDevices.filter(device => {
+        return device.sessionId !== this._sessionId && !this._pidService.isAlive(device.pid);
+      });
+
+      for (const id of zombieDevices.getIds()) {
+        allDevices.delete(id);
+      }
+      this._lockfile.write([...allDevices]);
+    });
+  }
+
+  /**
+   * @returns {Promise<DeviceList>}
+   */
+  async readSessionDevices() {
+    let devices;
+    await this._lockfile.exclusively(() => {
+      devices = this._getSessionDevicesSync();
+    });
+    return devices;
+  }
+
+  getTakenDevicesSync() {
+    const allDevices = this._getRegisteredDevices();
+    const busyDevices = allDevices.filter(device => device.busy);
+    const externalDevices = allDevices.filter(device => device.sessionId !== this._sessionId);
+    return busyDevices.concat(externalDevices);
+  }
+
+  /***
+   * @private
+   */
+  _getInitialLockFileState() {
+    return [];
+  }
+
+  /**
+   * @private
+   */
+  _upsertDevice(deviceId, data) {
+    const devices = this._getRegisteredDevices();
+    devices.add(deviceId, data);
+    this._lockfile.write([...devices]);
+  }
+
+  /**
+   * @private
+   */
+  _deleteDevice(deviceId) {
+    const devices = this._getRegisteredDevices();
+    devices.delete(deviceId);
+    this._lockfile.write([...devices]);
+  }
+
+  /***
+   * @private
+   * @returns {DeviceList}
+   */
+  _getRegisteredDevices() {
+    const devices = this._lockfile.read();
+    return new DeviceList(devices);
+  }
+
+  _getSessionDevicesSync() {
+    const devices = this._getRegisteredDevices();
+    const sessionDevices = devices.filter(device => device.sessionId === this._sessionId);
+    return sessionDevices;
+  }
+}
+
+module.exports = DeviceRegistry;

package/src/devices/allocation/drivers/AllocationDriverBase.d.ts

@@ -0,0 +1,15 @@
+/* eslint-disable import/no-unresolved,node/no-missing-import,node/no-unsupported-features/es-syntax */
+import { DeviceCookie } from '../../common/drivers/DeviceCookie';
+
+export interface DeallocOptions {
+  shutdown?: boolean;
+}
+
+export interface AllocationDriverBase {
+  init?(): Promise<void>;
+  allocate(deviceConfig: any): Promise<DeviceCookie>;
+  postAllocate?(deviceCookie: DeviceCookie): Promise<DeviceCookie | void>;
+  free(cookie: DeviceCookie, options: DeallocOptions): Promise<void>;
+  cleanup?(): Promise<void>;
+  emergencyCleanup?(): void;
+}