detox 20.12.2 → 20.13.0

package/Detox-android/com/wix/detox/20.13.0/detox-20.13.0-javadoc.jar.md5

@@ -0,0 +1 @@
+0709a8a30b2cc4c27244a2257ac28ed7

package/Detox-android/com/wix/detox/20.13.0/detox-20.13.0-javadoc.jar.sha1

@@ -0,0 +1 @@
+08f017a03aa160bead65af9b208ea95857ac9697

package/Detox-android/com/wix/detox/20.13.0/detox-20.13.0-javadoc.jar.sha256

@@ -0,0 +1 @@
+5cc49445c8f5440e5e5ed8d2d95e4827fb1ab4796d20e32ab30d7151da661ce7

package/Detox-android/com/wix/detox/20.13.0/detox-20.13.0-javadoc.jar.sha512

@@ -0,0 +1 @@
+7360ab285d19450619f38c7da9985fda6514d382f903e87a2af9d4e0204a0250851c412a045da6ce04cc932e9addf7c131fd5147889975be20910e2fdc64e88f

package/Detox-android/com/wix/detox/20.13.0/detox-20.13.0-sources.jar.md5

@@ -0,0 +1 @@
+972fa81d6c5d9f0eb6edc63765bf01af

package/Detox-android/com/wix/detox/20.13.0/detox-20.13.0-sources.jar.sha1

@@ -0,0 +1 @@
+1ea26448826d4701a7dce9d2c0c24355853ad9d7

package/Detox-android/com/wix/detox/20.13.0/detox-20.13.0-sources.jar.sha256

@@ -0,0 +1 @@
+6b2f9a8186f2eef1075910eae28c189ac2030561520277e503e3a696f3c977e2

package/Detox-android/com/wix/detox/20.13.0/detox-20.13.0-sources.jar.sha512

@@ -0,0 +1 @@
+eae9264b4d57f78a80ecffae3c85e157a2cd1df1b2259c0edc93f5c22d305a004216c5e9e6b35a1415fab6ba14a4f6667acd2eac4d5c6ae5a7a410ee85ca2c7c

package/Detox-android/com/wix/detox/{20.12.2/detox-20.12.2.pom → 20.13.0/detox-20.13.0.pom}

@@ -3,7 +3,7 @@
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.wix</groupId>
   <artifactId>detox</artifactId>
-  <version>20.12.2</version>
+  <version>20.13.0</version>
   <packaging>aar</packaging>
   <name>Detox</name>
   <description>Gray box end-to-end testing and automation library for mobile apps</description>

package/Detox-android/com/wix/detox/20.13.0/detox-20.13.0.pom.md5

@@ -0,0 +1 @@
+293aa59dd07a84b7a1bd7c4dc2bffe16

package/Detox-android/com/wix/detox/20.13.0/detox-20.13.0.pom.sha1

@@ -0,0 +1 @@
+144cef7278f92d8e7798cae134d8f93136492080

package/Detox-android/com/wix/detox/20.13.0/detox-20.13.0.pom.sha256

@@ -0,0 +1 @@
+a1062bb5feb8cb7210de7f0e2c36d8a219f8d4065377c9ced13ae55d7eb13220

package/Detox-android/com/wix/detox/20.13.0/detox-20.13.0.pom.sha512

@@ -0,0 +1 @@
+216ecb00454a1e03ef9ab2a197b616c4d326ec6ef47fd08b83b22d57c2c9d4dc37725a3c4d19600874074b40918387cebd1be11d558270af4ab7e797af40607f

package/Detox-android/com/wix/detox/maven-metadata.xml

@@ -3,11 +3,11 @@
   <groupId>com.wix</groupId>
   <artifactId>detox</artifactId>
   <versioning>
-    <latest>20.12.2</latest>
-    <release>20.12.2</release>
+    <latest>20.13.0</latest>
+    <release>20.13.0</release>
     <versions>
-      <version>20.12.2</version>
+      <version>20.13.0</version>
     </versions>
-    <lastUpdated>20230927202100</lastUpdated>
+    <lastUpdated>20231002075250</lastUpdated>
   </versioning>
 </metadata>

package/Detox-android/com/wix/detox/maven-metadata.xml.md5

@@ -1 +1 @@
-c4e29695a8333254dfdb58e83b723a94
+253d464cc30a2d00e586eadca31d5952

package/Detox-android/com/wix/detox/maven-metadata.xml.sha1

@@ -1 +1 @@
-8c90e83ee27dd4d9370742524f141054555c926b
+1a402a8246b4532c9be982b61c2b4d3b3e6ab741

package/Detox-android/com/wix/detox/maven-metadata.xml.sha256

@@ -1 +1 @@
-5fb1606470374345397232c3529c053c5aa26fd8650b3f7d9706f251a7f2e3b8
+09104c2799b83cedb2f68628779529f7efb1e96b3e33c0ed8c814da6a5e19ef8

package/Detox-android/com/wix/detox/maven-metadata.xml.sha512

@@ -1 +1 @@
-541d2924f1ccdd6c901ba584a978d8d26ba3027c6abca381dcb6b2553b4b730ca428d6743bc9d1fe0836e2662a4e81f5d53049fa164376173e76960fcdc33ccc
+b1547a601cae891dc3f1a58b66c63e70670d9f3e512c50cb6d26d40568972b94cb2f28887c13ea8d04e2b75b57bba73f8ba4ad780b471009fed3cd4e42b469ae

package/local-cli/reset-lock-file.js

@@ -1,16 +1,12 @@
 const { log } = require('../internals');
-const DeviceRegistry = require('../src/devices/DeviceRegistry');
-const { getDetoxLibraryRootPath } = require('../src/utils/environment');
-
+const DeviceRegistry = require('../src/devices/allocation/DeviceRegistry');
 
 module.exports.command = 'reset-lock-file';
-module.exports.desc = 'Resets all Detox lock files. Useful when you need to run multiple `detox test` commands in parallel with --keepLockFile.';
+module.exports.desc = 'Resets Detox lock file completely - all devices are marked as available after that.';
 
 module.exports.handler = async function resetLockFile() {
-  await Promise.all([
-    DeviceRegistry.forIOS().reset(),
-    DeviceRegistry.forAndroid().reset(),
-  ]);
+  const registry = new DeviceRegistry();
+  await registry.reset();
 
-  log.info(`Cleaned lock files from: ${getDetoxLibraryRootPath()}`);
+  log.info(`Cleaned lock file at: ${registry.lockFilePath}`);
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "detox",
   "description": "E2E tests and automation for mobile",
-  "version": "20.12.2",
+  "version": "20.13.0",
   "bin": {
     "detox": "local-cli/cli.js"
   },
@@ -137,9 +137,9 @@
       "src/artifacts/log",
       "src/artifacts/screenshot",
       "src/artifacts/video",
-      "src/devices/allocation/drivers/AllocationDriverBase.js",
       "src/devices/allocation/drivers/android/emulator/launchEmulatorProcess.js",
       "src/devices/allocation/drivers/android/emulator/patchAvdSkinConfig.js",
+      "src/devices/allocation/.*AllocDriver.js",
       "src/devices/allocation/drivers/ios",
       "src/devices/allocation/factories",
       "src/devices/allocation/factories/drivers",
@@ -154,10 +154,9 @@
       "src/devices/runtime/drivers/ios",
       "src/devices/runtime/factories",
       "src/devices/runtime/factories/drivers",
+      "src/devices/validation/EnvironmentValidatorBase.js",
+      "src/devices/validation/factories",
       "src/matchers/factories",
-      "src/validation/EnvironmentValidatorBase.js",
-      "src/validation/factories",
-      "src/validation/ios/IosSimulatorEnvValidator",
       "src/utils/appdatapath.js",
       "src/utils/debug.js",
       "src/utils/environment.js",
@@ -206,5 +205,5 @@
   "browserslist": [
     "node 14"
   ],
-  "gitHead": "3ed86bf3628cda4673412a4e2c38e32077473851"
+  "gitHead": "72e85a2fe078a2a721628255249410423fc5c1ac"
 }

package/runners/jest/testEnvironment/index.js

@@ -70,7 +70,7 @@ class DetoxCircusEnvironment extends NodeEnvironment {
     await this.initDetox();
   }
 
-  // @ts-ignore
+  // @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');

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;
+}