detox 21.0.0-rc.6 → 21.0.0-rc.7

package/src/{servicelocator → devices/servicelocator}/android/emulatorServiceLocator.js

@@ -1,4 +1,4 @@
-const { EmulatorExec } = require('../../devices/common/drivers/android/emulator/exec/EmulatorExec');
+const { EmulatorExec } = require('../../common/drivers/android/emulator/exec/EmulatorExec');
 
 class EmulatorServiceLocator {
   constructor() {

package/src/devices/servicelocator/android/genycloudServiceLocator.js

@@ -0,0 +1,17 @@
+class GenycloudServiceLocator {
+  constructor() {
+    this._exec = null;
+  }
+
+  // Note: important to keep lazy because of implicit validations that are sensitive (inside environment, in particular).
+  get exec() {
+    if (!this._exec) {
+      const Exec = require('../../allocation/drivers/android/genycloud/exec/GenyCloudExec');
+      const environment = require('../../../utils/environment');
+      this._exec = new Exec(environment.getGmsaasPath());
+    }
+    return this._exec;
+  }
+}
+
+module.exports = new GenycloudServiceLocator();

package/src/devices/servicelocator/android/index.js

@@ -0,0 +1,23 @@
+const AndroidDevicePathBuilder = require('../../../artifacts/utils/AndroidDevicePathBuilder');
+const AAPT = require('../../common/drivers/android/exec/AAPT');
+const ADB = require('../../common/drivers/android/exec/ADB');
+const ApkValidator = require('../../common/drivers/android/tools/ApkValidator');
+const { TempFileTransfer } = require('../../common/drivers/android/tools/TempFileTransfer');
+
+const AndroidServiceLocator = {
+  get emulator() {
+    return require('./emulatorServiceLocator');
+  },
+
+  get genycloud() {
+    return require('./genycloudServiceLocator');
+  },
+};
+
+AndroidServiceLocator.adb = new ADB();
+AndroidServiceLocator.aapt = new AAPT();
+AndroidServiceLocator.apkValidator = new ApkValidator(AndroidServiceLocator.aapt);
+AndroidServiceLocator.fileTransfer = new TempFileTransfer(AndroidServiceLocator.adb);
+AndroidServiceLocator.devicePathBuilder = new AndroidDevicePathBuilder();
+
+module.exports = AndroidServiceLocator;

package/src/{validation → devices/validation}/EnvironmentValidatorBase.js

@@ -1,4 +1,5 @@
 class EnvironmentValidatorBase {
+  /* istanbul ignore next */
   validate() {}
 }
 

package/src/{validation → devices/validation}/android/GenycloudEnvValidator.js

@@ -1,8 +1,8 @@
 // @ts-nocheck
 const semver = require('semver');
 
-const DetoxRuntimeError = require('../../errors/DetoxRuntimeError');
-const environment = require('../../utils/environment');
+const { DetoxRuntimeError } = require('../../../errors');
+const environment = require('../../../utils/environment');
 const EnvironmentValidatorBase = require('../EnvironmentValidatorBase');
 
 const MIN_GMSAAS_VERSION = '1.6.0';

package/src/{validation → devices/validation}/factories/index.js

@@ -7,7 +7,7 @@ class Genycloud extends EnvValidatorFactory {
     const serviceLocator = require('../../servicelocator/android');
     const exec = serviceLocator.genycloud.exec;
 
-    const GenyAuthService = require('../../devices/common/drivers/android/genycloud/services/GenyAuthService');
+    const GenyAuthService = require('../../allocation/drivers/android/genycloud/services/GenyAuthService');
     const authService = new GenyAuthService(exec);
 
     const GenycloudEnvValidator = require('../android/GenycloudEnvValidator');

package/src/{validation → devices/validation}/ios/IosSimulatorEnvValidator.js

@@ -1,7 +1,7 @@
 const fs = require('fs');
 
-const DetoxRuntimeError = require('../../errors/DetoxRuntimeError');
-const environment = require('../../utils/environment');
+const DetoxRuntimeError = require('../../../errors/DetoxRuntimeError');
+const environment = require('../../../utils/environment');
 const EnvironmentValidatorBase = require('../EnvironmentValidatorBase');
 
 class IosSimulatorEnvValidator extends EnvironmentValidatorBase {

package/src/environmentFactory.js

@@ -2,9 +2,9 @@
 const artifactsManagerFactories = require('./artifacts/factories');
 const deviceAllocationFactories = require('./devices/allocation/factories');
 const runtimeDeviceFactories = require('./devices/runtime/factories');
+const envValidationFactories = require('./devices/validation/factories');
 const matchersFactories = require('./matchers/factories');
 const resolveModuleFromPath = require('./utils/resolveModuleFromPath');
-const envValidationFactories = require('./validation/factories');
 
 function validateConfig(deviceConfig) {
   const classes = _getFactoryClasses(deviceConfig);
@@ -36,15 +36,6 @@ function createFactories(deviceConfig) {
   return _getExternalModuleFactories(deviceConfig);
 }
 
-function createGlobalLifecycleHandler(deviceConfig) {
-  if (deviceConfig.type === 'android.genycloud') {
-    const FactoryClass = require('./devices/lifecycle/factories/GenyGlobalLifecycleHandlerFactory');
-    const factory = new FactoryClass();
-    return factory.createHandler();
-  }
-  return null;
-}
-
 function _getFactoryClasses(deviceConfig) {
   let envValidatorFactoryClass;
   let artifactsManagerFactoryClass;
@@ -115,5 +106,4 @@ function _getExternalModuleFactories(deviceConfig) {
 module.exports = {
   validateConfig,
   createFactories,
-  createGlobalLifecycleHandler,
 };

package/src/ios/web.js

@@ -121,14 +121,30 @@ class WebElement {
     return this.withAction('moveCursorToEnd', traceDescription);
   }
 
-  runScript(script) {
+  async runScript(script, args) {
+    if (args !== undefined && args.length !== 0) {
+      return await this.runScriptWithArgs(script, args);
+    }
+
     const traceDescription = webViewActionDescription.runScript(script);
-    return this.withAction('runScript', traceDescription, script);
+    const result = await this.withAction('runScript', traceDescription, script);
+
+    if (result['result'] !== undefined) {
+      return result['result'];
+    } else {
+      throw new DetoxRuntimeError(`Failed to extract result from result: ${JSON.stringify(result)}`);
+    }
   }
 
-  runScriptWithArgs(script, ...args) {
-    const traceDescription = webViewActionDescription.runScriptWithArgs(script, ...args);
-    return this.withAction('runScriptWithArgs', traceDescription, script, ...args);
+  async runScriptWithArgs(script, args) {
+    const traceDescription = webViewActionDescription.runScriptWithArgs(script, args);
+    const result = await this.withAction('runScriptWithArgs', traceDescription, script, args);
+
+    if (result['result'] !== undefined) {
+      return result['result'];
+    } else {
+      throw new DetoxRuntimeError(`Failed to extract result from result: ${JSON.stringify(result)}`);
+    }
   }
 
   async getCurrentUrl() {

package/src/ipc/IPCClient.js

@@ -1,7 +1,7 @@
 const { IPC } = require('node-ipc');
 
 const { DetoxInternalError } = require('../errors');
-const { serializeObjectWithError } = require('../utils/errorUtils');
+const { serializeObjectWithError, deserializeObjectWithError } = require('../utils/errorUtils');
 
 class IPCClient {
   constructor({ id, logger, sessionState }) {
@@ -60,6 +60,22 @@ class IPCClient {
     this._sessionState.patch(sessionState);
   }
 
+  async allocateDevice() {
+    const { deviceCookie, error } = deserializeObjectWithError(await this._emit('allocateDevice', {}));
+    if (error) {
+      throw error;
+    }
+
+    return deviceCookie;
+  }
+
+  async deallocateDevice(deviceCookie) {
+    const { error } = deserializeObjectWithError(await this._emit('deallocateDevice', { deviceCookie }));
+    if (error) {
+      throw error;
+    }
+  }
+
   /**
    * @param {DetoxInternals.DetoxTestFileReport[]} testResults
    */
@@ -70,6 +86,11 @@ class IPCClient {
     this._sessionState.patch(sessionState);
   }
 
+  async conductEarlyTeardown({ permanent }) {
+    const sessionState = await this._emit('conductEarlyTeardown', { permanent });
+    this._sessionState.patch(sessionState);
+  }
+
   async _connectToServer() {
     const serverId = this.serverId;
 

package/src/ipc/IPCServer.js

@@ -8,11 +8,15 @@ class IPCServer {
    * @param {object} options
    * @param {import('./SessionState')} options.sessionState
    * @param {Detox.Logger} options.logger
+   * @param {object} options.callbacks
+   * @param {() => Promise<any>} options.callbacks.onAllocateDevice
+   * @param {(cookie: any) => Promise<void>} options.callbacks.onDeallocateDevice
    */
-  constructor({ sessionState, logger }) {
+  constructor({ sessionState, logger, callbacks }) {
     this._sessionState = sessionState;
     this._logger = logger.child({ cat: 'ipc,ipc-server' });
     this._ipc = null;
+    this._callbacks = callbacks;
     this._workers = new Set();
     this._contexts = new Set();
   }
@@ -38,9 +42,12 @@ class IPCServer {
     await new Promise((resolve) => {
       // TODO: handle reject
       this._ipc.serve(() => resolve());
+      this._ipc.server.on('conductEarlyTeardown', this.onConductEarlyTeardown.bind(this));
       this._ipc.server.on('registerContext', this.onRegisterContext.bind(this));
       this._ipc.server.on('registerWorker', this.onRegisterWorker.bind(this));
       this._ipc.server.on('reportTestResults', this.onReportTestResults.bind(this));
+      this._ipc.server.on('allocateDevice', this.onAllocateDevice.bind(this));
+      this._ipc.server.on('deallocateDevice', this.onDeallocateDevice.bind(this));
       this._ipc.server.start();
     });
   }
@@ -66,6 +73,7 @@ class IPCServer {
     this._ipc.server.emit(socket, 'registerContextDone', {
       testResults: this._sessionState.testResults,
       testSessionIndex: this._sessionState.testSessionIndex,
+      unsafe_earlyTeardown: this._sessionState.unsafe_earlyTeardown,
     });
   }
 
@@ -83,6 +91,39 @@ class IPCServer {
     }
   }
 
+  onConductEarlyTeardown({ permanent }, socket = null) {
+    const newState = { unsafe_earlyTeardown: true };
+    if (permanent) {
+      Object.assign(this._sessionState, newState);
+    }
+
+    if (socket) {
+      this._ipc.server.emit(socket, 'conductEarlyTeardownDone', newState);
+    }
+
+    this._ipc.server.broadcast('sessionStateUpdate', newState);
+  }
+
+  async onAllocateDevice(_payload, socket) {
+    let deviceCookie;
+
+    try {
+      deviceCookie = await this._callbacks.onAllocateDevice();
+      this._ipc.server.emit(socket, 'allocateDeviceDone', { deviceCookie });
+    } catch (error) {
+      this._ipc.server.emit(socket, 'allocateDeviceDone', serializeObjectWithError({ error }));
+    }
+  }
+
+  async onDeallocateDevice({ deviceCookie }, socket) {
+    try {
+      await this._callbacks.onDeallocateDevice(deviceCookie);
+      this._ipc.server.emit(socket, 'deallocateDeviceDone', {});
+    } catch (error) {
+      this._ipc.server.emit(socket, 'deallocateDeviceDone', serializeObjectWithError({ error }));
+    }
+  }
+
   onReportTestResults({ testResults }, socket = null) {
     const merged = uniqBy([
       ...testResults.map(r => serializeObjectWithError(r, 'testExecError')),

package/src/ipc/SessionState.js

@@ -20,6 +20,7 @@ class SessionState {
     this.detoxIPCServer = detoxIPCServer;
     this.testResults = testResults;
     this.testSessionIndex = testSessionIndex;
+    this.unsafe_earlyTeardown = undefined;
     this.workersCount = workersCount;
   }
 

package/src/logger/DetoxLogger.js

@@ -249,7 +249,7 @@ class DetoxLogger {
   _complete(level, maybeContext, maybeMessage, maybeAction) {
     const action = typeof maybeContext !== 'string' ? maybeAction : maybeMessage;
     const args = maybeAction === action ? [maybeContext, maybeMessage] : [maybeContext];
-    const { context, msg } = this._parseArgs(null, args);
+    const { context, msg } = this._parseArgs({ ph: 'B' }, args);
     const end = (ctx) => this[level].end({
       id: context.id,
       cat: context.cat,
@@ -257,7 +257,7 @@ class DetoxLogger {
     });
 
     let result;
-    this._beginInternal(level, { ...context, ph: 'B' }, msg);
+    this._beginInternal(level, context, msg);
     try {
       result = typeof action === 'function'
         ? action()

package/src/realms/DetoxContext.js

@@ -101,6 +101,8 @@ class DetoxContext {
   });
   /** @abstract */
   [symbols.reportTestResults](_testResults) {}
+  /** @abstract */
+  [symbols.conductEarlyTeardown](_permanent) {}
   /**
    * @abstract
    * @param {Partial<DetoxInternals.DetoxInitOptions>} _opts
@@ -149,6 +151,12 @@ class DetoxContext {
     await this[$worker].init();
   }
 
+  /** @abstract */
+  async [symbols.allocateDevice]() {}
+
+  /** @abstract */
+  async [symbols.deallocateDevice]() {}
+
   async [symbols.uninstallWorker]() {
     try {
       if (this[$worker]) {

package/src/realms/DetoxInternalsFacade.js

@@ -24,6 +24,7 @@ class DetoxInternalsFacade {
     this.resolveConfig = context[symbols.resolveConfig];
     this.session = context[symbols.session];
     this.tracing = context[symbols.tracing];
+    this.unsafe_conductEarlyTeardown = context[symbols.conductEarlyTeardown];
     this.worker = funpermaproxy(() => context[symbols.worker]);
   }
 }

package/src/realms/DetoxPrimaryContext.js

@@ -16,15 +16,14 @@ const symbols = require('./symbols');
 const { $logFinalizer, $restoreSessionState, $sessionState, $worker } = DetoxContext.protected;
 
 //#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 _lifecycleLogger = Symbol('lifecycleLogger');
 const _sessionFile = Symbol('sessionFile');
 const _logFinalError = Symbol('logFinalError');
+const _deviceAllocator = Symbol('deviceAllocator');
 //#endregion
 
 class DetoxPrimaryContext extends DetoxContext {
@@ -33,7 +32,8 @@ class DetoxPrimaryContext extends DetoxContext {
 
     this[_dirty] = false;
     this[_wss] = null;
-    this[_globalLifecycleHandler] = null;
+    this[_deviceAllocator] = null;
+
     /** Path to file where the initial session object is serialized */
     this[_sessionFile] = '';
     /**
@@ -51,6 +51,12 @@ class DetoxPrimaryContext extends DetoxContext {
     }
   }
 
+  [symbols.conductEarlyTeardown] = async (permanent = false) => {
+    if (this[_ipcServer]) {
+      await this[_ipcServer].onConductEarlyTeardown({ permanent });
+    }
+  };
+
   async [symbols.resolveConfig](opts = {}) {
     const session = this[$sessionState];
     if (!session.detoxConfig) {
@@ -79,7 +85,6 @@ class DetoxPrimaryContext extends DetoxContext {
     const detoxConfig = await this[symbols.resolveConfig](opts);
 
     const {
-      behavior: behaviorConfig,
       device: deviceConfig,
       logger: loggerConfig,
       session: sessionConfig
@@ -96,20 +101,23 @@ class DetoxPrimaryContext extends DetoxContext {
     this[_ipcServer] = new IPCServer({
       sessionState: this[$sessionState],
       logger: this[symbols.logger],
+      callbacks: {
+        onAllocateDevice: this[symbols.allocateDevice].bind(this),
+        onDeallocateDevice: this[symbols.deallocateDevice].bind(this),
+      },
     });
 
     await this[_ipcServer].init();
 
     const environmentFactory = require('../environmentFactory');
-    this[_globalLifecycleHandler] = await environmentFactory.createGlobalLifecycleHandler(deviceConfig);
 
-    if (this[_globalLifecycleHandler]) {
-      await this[_globalLifecycleHandler].globalInit();
-    }
+    const { deviceAllocatorFactory } = environmentFactory.createFactories(deviceConfig);
+    this[_deviceAllocator] = deviceAllocatorFactory.createDeviceAllocator({
+      detoxConfig,
+      detoxSession: this[$sessionState],
+    });
 
-    if (!behaviorConfig.init.keepLockFile) {
-      await this[_resetLockFile]();
-    }
+    await this[_deviceAllocator].init();
 
     // TODO: Detox-server creation ought to be delegated to a generator/factory.
     const DetoxServer = require('../server/DetoxServer');
@@ -153,6 +161,29 @@ class DetoxPrimaryContext extends DetoxContext {
     await super[symbols.installWorker]({ ...opts, workerId });
   }
 
+  /** @override */
+  async [symbols.allocateDevice]() {
+    const { device } = this[$sessionState].detoxConfig;
+    const deviceCookie = await this[_deviceAllocator].allocate(device);
+
+    try {
+      return await this[_deviceAllocator].postAllocate(deviceCookie);
+    } catch (e) {
+      try {
+        await this[_deviceAllocator].free(deviceCookie, { shutdown: true });
+      } catch (e2) {
+        this[symbols.logger].error({ cat: 'device', err: e2 }, `Failed to free ${deviceCookie.name || deviceCookie.id} after a failed allocation`);
+      }
+
+      throw e;
+    }
+  }
+
+  /** @override */
+  async [symbols.deallocateDevice](cookie) {
+    await this[_deviceAllocator].free(cookie);
+  }
+
   /** @override */
   async [symbols.cleanup]() {
     try {
@@ -160,9 +191,9 @@ class DetoxPrimaryContext extends DetoxContext {
         await this[symbols.uninstallWorker]();
       }
     } finally {
-      if (this[_globalLifecycleHandler]) {
-        await this[_globalLifecycleHandler].globalCleanup();
-        this[_globalLifecycleHandler] = null;
+      if (this[_deviceAllocator]) {
+        await this[_deviceAllocator].cleanup();
+        this[_deviceAllocator] = null;
       }
 
       if (this[_wss]) {
@@ -196,9 +227,9 @@ class DetoxPrimaryContext extends DetoxContext {
       return;
     }
 
-    if (this[_globalLifecycleHandler]) {
-      this[_globalLifecycleHandler].emergencyCleanup();
-      this[_globalLifecycleHandler] = null;
+    if (this[_deviceAllocator]) {
+      this[_deviceAllocator].emergencyCleanup();
+      this[_deviceAllocator] = null;
     }
 
     if (this[_wss]) {
@@ -241,31 +272,6 @@ class DetoxPrimaryContext extends DetoxContext {
     });
   }
   //#endregion
-
-  //#region Private members
-  async[_resetLockFile]() {
-    const DeviceRegistry = require('../devices/DeviceRegistry');
-
-    const deviceType = this[symbols.config].device.type;
-
-    switch (deviceType) {
-      case 'ios.none':
-      case 'ios.simulator':
-        await DeviceRegistry.forIOS().reset();
-        break;
-      case 'android.attached':
-      case 'android.emulator':
-      case 'android.genycloud':
-        await DeviceRegistry.forAndroid().reset();
-        break;
-    }
-
-    if (deviceType === 'android.genycloud') {
-      const GenyDeviceRegistryFactory = require('../devices/allocation/drivers/android/genycloud/GenyDeviceRegistryFactory');
-      await GenyDeviceRegistryFactory.forGlobalShutdown().reset();
-    }
-  }
-  //#endregion
 }
 
 module.exports = DetoxPrimaryContext;

package/src/realms/DetoxSecondaryContext.js

@@ -33,6 +33,14 @@ class DetoxSecondaryContext extends DetoxContext {
     }
   }
 
+  [symbols.conductEarlyTeardown] = async (permanent = false) => {
+    if (this[_ipcClient]) {
+      await this[_ipcClient].conductEarlyTeardown({ permanent });
+    } else {
+      throw new DetoxInternalError('Detected an attempt to report early teardown using a non-initialized context.');
+    }
+  };
+
   async [symbols.resolveConfig]() {
     return this[symbols.config];
   }
@@ -54,6 +62,25 @@ class DetoxSecondaryContext extends DetoxContext {
     }
   }
 
+  /** @override */
+  async [symbols.allocateDevice]() {
+    if (this[_ipcClient]) {
+      const deviceCookie = await this[_ipcClient].allocateDevice();
+      return deviceCookie;
+    } else {
+      throw new DetoxInternalError('Detected an attempt to allocate a device using a non-initialized context.');
+    }
+  }
+
+  /** @override */
+  async [symbols.deallocateDevice](deviceCookie) {
+    if (this[_ipcClient]) {
+      await this[_ipcClient].deallocateDevice(deviceCookie);
+    } else {
+      throw new DetoxInternalError('Detected an attempt to allocate a device using a non-initialized context.');
+    }
+  }
+
   /** @override */
   async [symbols.cleanup]() {
     try {

package/src/realms/symbols.js

@@ -5,6 +5,8 @@
  *   readonly getStatus: unique symbol;
  *   readonly init: unique symbol;
  *   readonly installWorker: unique symbol;
+ *   readonly allocateDevice: unique symbol;
+ *   readonly deallocateDevice: unique symbol;
  *   readonly logger: unique symbol;
  *   readonly onHookFailure: unique symbol;
  *   readonly onRunDescribeFinish: unique symbol;
@@ -12,6 +14,7 @@
  *   readonly onTestDone: unique symbol;
  *   readonly onTestFnFailure: unique symbol;
  *   readonly onTestStart: unique symbol;
+ *   readonly conductEarlyTeardown: unique symbol;
  *   readonly reportTestResults: unique symbol;
  *   readonly resolveConfig: unique symbol;
  *   readonly session: unique symbol;
@@ -32,6 +35,9 @@ module.exports = {
 
   //#region IPC
   reportTestResults: Symbol('reportTestResults'),
+  conductEarlyTeardown: Symbol('conductEarlyTeardown'),
+  allocateDevice: Symbol('allocateDevice'),
+  deallocateDevice: Symbol('deallocateDevice'),
   //#endregion
 
   //#region Main

package/src/utils/PIDService.js

@@ -0,0 +1,27 @@
+const { pid } = require('process');
+
+class PIDService {
+  getPid() {
+    return pid;
+  }
+
+  /**
+   * Checks if the other process id is running in the current operating system
+   * @param {number} otherPID
+   * @returns {boolean}
+   */
+  isAlive(otherPID) {
+    try {
+      process.kill(otherPID, 0);
+      return true;
+    } catch (ex) {
+      if (ex.code === 'ESRCH') {
+        return false;
+      }
+      throw ex;
+    }
+  }
+
+}
+
+module.exports = PIDService;

package/src/utils/assertIsFunction.js

@@ -0,0 +1,35 @@
+const isArrowFunction = require('./isArrowFunction');
+
+const EXAMPLE = `Here are some examples of valid function strings:
+
+1. function(el) { el.click(); }
+2. el => el.click()
+3. (el) => el.click()
+`;
+
+/**
+ * Dynamically evaluates a string as a function and throws an error if it's not a function
+ * @param {string} str serialized function like 'function() { return 42; }'
+ */
+function assertIsFunction(str) {
+  let isFunction;
+
+  try {
+    isFunction = isFunctionDeclaration(str) && Function(`return typeof (${str})`)() === 'function';
+  } catch (e) {
+    isFunction = false;
+  }
+
+  if (!isFunction) {
+    throw new TypeError(`Expected a valid function string, but got: ${str}\n\n${EXAMPLE}`);
+  }
+
+  return str;
+}
+
+function isFunctionDeclaration(rawStr) {
+  const str = rawStr.trimStart();
+  return str.startsWith('async') || str.startsWith('function') || isArrowFunction(str);
+}
+
+module.exports = assertIsFunction;