detox 19.9.0 → 21.0.0-breaking.new-global-lifecycle.0

package/src/artifacts/ArtifactsManager.js

@@ -7,18 +7,67 @@ const _ = require('lodash');
 
 const DetoxRuntimeError = require('../errors/DetoxRuntimeError');
 const log = require('../utils/logger').child({ __filename });
+const resolveModuleFromPath = require('../utils/resolveModuleFromPath');
+const { traceMethods } = require('../utils/trace');
 
 const FileArtifact = require('./templates/artifact/FileArtifact');
+const ArtifactPathBuilder = require('./utils/ArtifactPathBuilder');
 
 class ArtifactsManager extends EventEmitter {
-  constructor({ pathBuilder, plugins }) {
+  constructor({ rootDir, pathBuilder, plugins }) {
     super();
 
     this._pluginConfigs = plugins;
     this._idlePromise = Promise.resolve();
     this._idleCallbackRequests = [];
     this._artifactPlugins = {};
-    this._pathBuilder = pathBuilder;
+    this._pathBuilder = this._resolveArtifactsPathBuilder(pathBuilder, rootDir);
+
+    traceMethods(this, 'artifacts-manager,artifacts', [
+      'onAppReady',
+      'onBeforeCleanup',
+      'onBeforeLaunchApp',
+      'onBeforeShutdownDevice',
+      'onBeforeTerminateApp',
+      'onBeforeUninstallApp',
+      'onBootDevice',
+      'onCreateExternalArtifact',
+      'onHookFailure',
+      'onHookStart',
+      'onHookSuccess',
+      'onLaunchApp',
+      'onRunDescribeFinish',
+      'onRunDescribeStart',
+      'onRunFinish',
+      'onRunStart',
+      'onShutdownDevice',
+      'onTerminateApp',
+      'onTestDone',
+      'onTestFnFailure',
+      'onTestFnStart',
+      'onTestFnSuccess',
+      'onTestStart',
+    ]);
+  }
+
+  _resolveArtifactsPathBuilder(pathBuilder, rootDir) {
+    if (typeof pathBuilder === 'string') {
+      pathBuilder = resolveModuleFromPath(pathBuilder);
+
+      if (typeof pathBuilder === 'function') {
+        try {
+          pathBuilder = pathBuilder({ rootDir });
+        } catch (e) {
+          pathBuilder = new pathBuilder({ rootDir });
+        }
+      }
+    }
+
+    if (!pathBuilder) {
+      pathBuilder = new ArtifactPathBuilder({ rootDir });
+    }
+
+    return pathBuilder;
   }
 
   _instantiateArtifactPlugin(pluginFactory, pluginUserConfig) {

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

@@ -1,5 +1,6 @@
 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');
@@ -25,18 +26,26 @@ class ADBLogcatRecording extends Artifact {
     this._waitUntilLogFileIsCreated = null;
   }
 
+  get hasRecordedFile() {
+    return !!this._waitUntilLogFileIsCreated;
+  }
+
   async doStart() {
     const pid = this.pid.get();
 
-    this.processPromise = this.adb.logcat(this.deviceId, {
-      file: this.pathToLogOnDevice,
-      time: this.since.get(),
-      pid: pid > 0 ? pid : 0,
-    });
+    if (pid > 0) {
+      this.processPromise = this.adb.logcat(this.deviceId, {
+        file: this.pathToLogOnDevice,
+        time: this.since.get(),
+        pid,
+      });
 
-    this._waitUntilLogFileIsCreated = sleep(300).then(() => {
-      return retry(() => this._assertLogIsCreated());
-    });
+      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');
+    }
   }
 
   async doStop() {
@@ -52,12 +61,20 @@ class ADBLogcatRecording extends Artifact {
   }
 
   async doSave(artifactPath) {
-    await this.adb.pull(this.deviceId, this.pathToLogOnDevice, artifactPath);
-    await this.adb.rm(this.deviceId, this.pathToLogOnDevice);
+    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}`);
+    }
   }
 
   async doDiscard() {
-    await this.adb.rm(this.deviceId, this.pathToLogOnDevice);
+    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}`);
+    }
   }
 
   async _assertLogIsCreated() {

package/src/artifacts/providers/index.js

@@ -12,25 +12,21 @@ class AndroidArtifactPluginsProvider extends ArtifactPluginsProvider {
     const ADBLogcatPlugin = require('../log/android/ADBLogcatPlugin');
     const ADBScreencapPlugin = require('../screenshot/ADBScreencapPlugin');
     const ADBScreenrecorderPlugin = require('../video/ADBScreenrecorderPlugin');
-    const TimelineArtifactPlugin = require('../timeline/TimelineArtifactPlugin');
 
     return {
       instruments: (api) => new AndroidInstrumentsPlugin({ api, adb, client, devicePathBuilder }),
       log: (api) => new ADBLogcatPlugin({ api, adb, devicePathBuilder }),
       screenshot: (api) => new ADBScreencapPlugin({ api, adb, devicePathBuilder }),
       video: (api) => new ADBScreenrecorderPlugin({ api, adb, devicePathBuilder }),
-      timeline: (api) => new TimelineArtifactPlugin({ api }),
     };
   }
 }
 
 class IosArtifactPluginsProvider extends ArtifactPluginsProvider {
   declareArtifactPlugins({ client }) {
-    const TimelineArtifactPlugin = require('../timeline/TimelineArtifactPlugin');
     const IosUIHierarchyPlugin = require('../uiHierarchy/IosUIHierarchyPlugin');
 
     return {
-      timeline: (api) => new TimelineArtifactPlugin({ api }),
       uiHierarchy: (api) => new IosUIHierarchyPlugin({ api, client }),
     };
   }

package/src/artifacts/utils/buildDefaultArtifactsRootDirpath.js

@@ -4,12 +4,10 @@ const getTimeStampString = require('./getTimeStampString');
 
 function buildDefaultRootForArtifactsRootDirpath(configuration, rootDir) {
   if (rootDir.endsWith('/') || rootDir.endsWith('\\')) {
-    return rootDir;
+    return rootDir.slice(0, -1);
   }
 
-  const seed = Number(process.env.DETOX_START_TIMESTAMP || String(Date.now()));
-  const subdir = `${configuration}.${getTimeStampString(new Date(seed))}`;
-  return path.join(rootDir, subdir);
+  return path.join(rootDir, `${configuration}.${getTimeStampString(new Date())}`);
 }
 
 module.exports = buildDefaultRootForArtifactsRootDirpath;

package/src/artifacts/utils/temporaryPath.js

@@ -4,6 +4,8 @@ const tempfile = require('tempfile');
 
 module.exports = {
   for: {
+    json: () => tempfile('.detox.json'),
+    jsonl: () => tempfile('.detox.jsonl'),
     png: () => tempfile('.detox.png'),
     log: () => tempfile('.detox.log'),
     mp4: () => tempfile('.detox.mp4'),

package/src/client/AsyncWebSocket.js

@@ -5,7 +5,7 @@ const WebSocket = require('ws');
 const DetoxInternalError = require('../errors/DetoxInternalError');
 const DetoxRuntimeError = require('../errors/DetoxRuntimeError');
 const Deferred = require('../utils/Deferred');
-const log = require('../utils/logger').child({ __filename });
+const log = require('../utils/logger').child({ __filename, cat: 'ws-client,ws' });
 
 const InflightRequest = require('./InflightRequest');
 

package/src/client/actions/actions.js

@@ -1,6 +1,6 @@
 // @ts-nocheck
 const { DetoxInternalError, DetoxRuntimeError } = require('../../errors');
-const { getDetoxLevel } = require('../../utils/logger');
+const logger = require('../../utils/logger');
 const formatJSONStatus = require('../actions/formatters/SyncStatusFormatter');
 
 class Action {
@@ -201,7 +201,7 @@ class Invoke extends Action {
 
         if (response.params.viewHierarchy) {
           /* istanbul ignore next */
-          if (/^(debug|trace)$/.test(getDetoxLevel())) {
+          if (/^(debug|trace)$/.test(logger.level)) {
             debugInfo = 'View Hierarchy:\n' + response.params.viewHierarchy;
           } else {
             hint = 'To print view hierarchy on failed actions/matches, use log-level verbose or higher.';

package/src/configuration/collectCliConfig.js

@@ -36,7 +36,7 @@ const deprecateDeviceLaunchArgs = (value) => {
 function collectCliConfig({ argv }) {
   const env = (key) => argparse.getArgValue(key);
   const get = (key, fallback) => {
-    const value = argv ? argv[key] : env(key);
+    const value = argv && Reflect.has(argv, key) ? argv[key] : env(key);
     return value === undefined ? fallback : value;
   };
 
@@ -47,7 +47,6 @@ function collectCliConfig({ argv }) {
     takeScreenshots: get('take-screenshots'),
     recordVideos: get('record-videos'),
     recordPerformance: get('record-performance'),
-    recordTimeline: get('record-timeline'),
     cleanup: asBoolean(get('cleanup')),
     configPath: get('config-path'),
     configuration: get('configuration'),
@@ -64,9 +63,8 @@ function collectCliConfig({ argv }) {
     loglevel: get('loglevel'),
     noColor: asBoolean(get('no-color')),
     reuse: asBoolean(get('reuse')),
-    runnerConfig: get('runner-config'),
     useCustomLogger: asBoolean(get('use-custom-logger')),
-    workers: asNumber(get('workers')),
+    retries: asNumber(get('retries')),
     inspectBrk: asBoolean(get('inspect-brk')),
   }, _.isUndefined);
 }

package/src/configuration/composeAppsConfig.js

@@ -1,6 +1,6 @@
 // @ts-nocheck
 const _ = require('lodash');
-const parse = require('yargs-parser');
+const parse = require('yargs/yargs').Parser;
 
 const deviceAppTypes = require('./utils/deviceAppTypes');
 
@@ -19,12 +19,7 @@ const CLI_PARSER_OPTIONS = {
  * @returns {Record<string, Detox.DetoxAppConfig>}
  */
 function composeAppsConfig(opts) {
-  const { localConfig } = opts;
-
-  const appsConfig = localConfig.type
-    ? composeAppsConfigFromPlain(opts)
-    : composeAppsConfigFromAliased(opts);
-
+  const appsConfig = composeAppsConfigFromAliased(opts);
   overrideAppLaunchArgs(appsConfig, opts.cliConfig);
 
   return appsConfig;
@@ -35,65 +30,7 @@ function composeAppsConfig(opts) {
  * @param {string} opts.configurationName
  * @param {Detox.DetoxDeviceConfig} opts.deviceConfig
  * @param {Detox.DetoxConfig} opts.globalConfig
- * @param {Detox.DetoxPlainConfiguration} opts.localConfig
- * @returns {Record<string, Detox.DetoxAppConfig>}
- */
-function composeAppsConfigFromPlain(opts) {
-  const { errorComposer, localConfig } = opts;
-
-  if (localConfig.app || localConfig.apps) {
-    throw errorComposer.oldSchemaHasAppAndApps();
-  }
-
-  /** @type {Detox.DetoxAppConfig} */
-  let appConfig;
-
-  switch (opts.deviceConfig.type) {
-    case 'android.attached':
-    case 'android.emulator':
-    case 'android.genycloud':
-      appConfig = {
-        type: 'android.apk',
-        binaryPath: localConfig.binaryPath,
-        bundleId: localConfig.bundleId,
-        build: localConfig.build,
-        testBinaryPath: localConfig.testBinaryPath,
-        launchArgs: localConfig.launchArgs,
-      }; break;
-    case 'ios.none':
-    case 'ios.simulator':
-      appConfig = {
-        type: 'ios.app',
-        binaryPath: localConfig.binaryPath,
-        bundleId: localConfig.bundleId,
-        build: localConfig.build,
-        launchArgs: localConfig.launchArgs,
-      };
-      break;
-    default:
-      appConfig = {
-        ...localConfig,
-      };
-  }
-
-  validateAppConfig({
-    errorComposer,
-    appConfig,
-    deviceConfig: opts.deviceConfig,
-    appPath: ['configurations', opts.configurationName],
-  });
-
-  return {
-    default: _.omitBy(appConfig, _.isUndefined),
-  };
-}
-
-/**
- * @param {DetoxConfigErrorComposer} opts.errorComposer
- * @param {string} opts.configurationName
- * @param {Detox.DetoxDeviceConfig} opts.deviceConfig
- * @param {Detox.DetoxConfig} opts.globalConfig
- * @param {Detox.DetoxAliasedConfiguration} opts.localConfig
+ * @param {Detox.DetoxConfiguration} opts.localConfig
  * @returns {Record<string, Detox.DetoxAppConfig>}
  */
 function composeAppsConfigFromAliased(opts) {
@@ -101,8 +38,13 @@ function composeAppsConfigFromAliased(opts) {
   const result = {};
   const { configurationName, errorComposer, deviceConfig, globalConfig, localConfig } = opts;
 
+  const isBuiltinDevice = Boolean(deviceAppTypes[deviceConfig.type]);
   if (localConfig.app == null && localConfig.apps == null) {
-    throw errorComposer.noAppIsDefined(deviceConfig.type);
+    if (isBuiltinDevice) {
+      throw errorComposer.noAppIsDefined(deviceConfig.type);
+    } else {
+      return result;
+    }
   }
 
   if (localConfig.app != null && localConfig.apps != null) {

package/src/configuration/composeArtifactsConfig.js

@@ -4,18 +4,15 @@ const _ = require('lodash');
 const InstrumentsArtifactPlugin = require('../artifacts/instruments/InstrumentsArtifactPlugin');
 const LogArtifactPlugin = require('../artifacts/log/LogArtifactPlugin');
 const ScreenshotArtifactPlugin = require('../artifacts/screenshot/ScreenshotArtifactPlugin');
-const TimelineArtifactPlugin = require('../artifacts/timeline/TimelineArtifactPlugin');
 const IosUIHierarchyPlugin = require('../artifacts/uiHierarchy/IosUIHierarchyPlugin');
-const ArtifactPathBuilder = require('../artifacts/utils/ArtifactPathBuilder');
 const buildDefaultArtifactsRootDirpath = require('../artifacts/utils/buildDefaultArtifactsRootDirpath');
 const VideoArtifactPlugin = require('../artifacts/video/VideoArtifactPlugin');
-const resolveModuleFromPath = require('../utils/resolveModuleFromPath');
 
 /**
  * @param {*} cliConfig
  * @param {string} configurationName
  * @param {Detox.DetoxConfig} globalConfig
- * @param {Detox.DetoxConfigurationOverrides} localConfig
+ * @param {Detox.DetoxConfiguration} localConfig
  */
 function composeArtifactsConfig({
   cliConfig,
@@ -31,7 +28,6 @@ function composeArtifactsConfig({
         screenshot: cliConfig.takeScreenshots,
         video: cliConfig.recordVideos,
         instruments: cliConfig.recordPerformance,
-        timeline: cliConfig.recordTimeline,
         uiHierarchy: cliConfig.captureViewHierarchy,
       },
     }),
@@ -40,13 +36,15 @@ function composeArtifactsConfig({
     extendArtifactsConfig(false),
   );
 
+  if (!artifactsConfig.pathBuilder) {
+    artifactsConfig.pathBuilder = undefined;
+  }
+
   artifactsConfig.rootDir = buildDefaultArtifactsRootDirpath(
     configurationName,
     artifactsConfig.rootDir
   );
 
-  artifactsConfig.pathBuilder = resolveArtifactsPathBuilder(artifactsConfig);
-
   return artifactsConfig;
 }
 
@@ -54,13 +52,12 @@ function extendArtifactsConfig(config) {
   if (config === false) {
     return extendArtifactsConfig({
       rootDir: 'artifacts',
-      pathBuilder: null,
+      pathBuilder: '',
       plugins: {
         log: 'none',
         screenshot: 'manual',
         video: 'none',
         instruments: 'none',
-        timeline: 'none',
         uiHierarchy: 'disabled',
       },
     });
@@ -79,34 +76,11 @@ function extendArtifactsConfig(config) {
       screenshot: ifString(p.screenshot, ScreenshotArtifactPlugin.parseConfig),
       video: ifString(p.video, VideoArtifactPlugin.parseConfig),
       instruments: ifString(p.instruments, InstrumentsArtifactPlugin.parseConfig),
-      timeline: ifString(p.timeline, TimelineArtifactPlugin.parseConfig),
       uiHierarchy: ifString(p.uiHierarchy, IosUIHierarchyPlugin.parseConfig),
     },
   };
 }
 
-function resolveArtifactsPathBuilder(artifactsConfig) {
-  let { rootDir, pathBuilder } = artifactsConfig;
-
-  if (typeof pathBuilder === 'string') {
-    pathBuilder = resolveModuleFromPath(pathBuilder);
-  }
-
-  if (typeof pathBuilder === 'function') {
-    try {
-      pathBuilder = pathBuilder({ rootDir });
-    } catch (e) {
-      pathBuilder = new pathBuilder({ rootDir });
-    }
-  }
-
-  if (!pathBuilder) {
-    pathBuilder = new ArtifactPathBuilder({ rootDir });
-  }
-
-  return pathBuilder;
-}
-
 function ifString(value, mapper) {
   return typeof value === 'string' ? mapper(value) : value;
 }

package/src/configuration/composeBehaviorConfig.js

@@ -4,36 +4,30 @@ const _ = require('lodash');
 /**
  * @param {*} cliConfig
  * @param {Detox.DetoxConfig} globalConfig
- * @param {Detox.DetoxConfigurationOverrides} localConfig
- * @param {Detox.DetoxInitOptions} userParams
+ * @param {Detox.DetoxConfiguration} localConfig
  */
 function composeBehaviorConfig({
   cliConfig,
   globalConfig,
   localConfig,
-  userParams
 }) {
   return _.chain({})
     .defaultsDeep(
       {
         init: {
+          keepLockFile: cliConfig.keepLockFile ? true : undefined,
           reinstallApp: cliConfig.reuse ? false : undefined,
         },
         cleanup: {
           shutdownDevice: cliConfig.cleanup ? true : undefined,
         },
       },
-      userParams && {
-        init: {
-          exposeGlobals: userParams.initGlobals,
-          reinstallApp: negateDefined(userParams.reuse),
-        },
-      },
       localConfig.behavior,
       globalConfig.behavior,
       {
         init: {
           exposeGlobals: true,
+          keepLockFile: false,
           reinstallApp: undefined,
         },
         launchApp: 'auto',
@@ -50,8 +44,4 @@ function composeBehaviorConfig({
     .value();
 }
 
-function negateDefined(x) {
-  return x !== undefined ? !x : undefined;
-}
-
 module.exports = composeBehaviorConfig;

package/src/configuration/composeDeviceConfig.js

@@ -12,13 +12,8 @@ const log = require('../utils/logger').child({ __filename });
  * @returns {Detox.DetoxDeviceConfig}
  */
 function composeDeviceConfig(opts) {
-  const { localConfig, cliConfig } = opts;
-
-  const deviceConfig = localConfig.type
-    ? composeDeviceConfigFromPlain(opts)
-    : composeDeviceConfigFromAliased(opts);
-
-  applyCLIOverrides(deviceConfig, cliConfig);
+  const deviceConfig = composeDeviceConfigFromAliased(opts);
+  applyCLIOverrides(deviceConfig, opts.cliConfig);
   deviceConfig.device = unpackDeviceQuery(deviceConfig);
 
   return deviceConfig;
@@ -27,29 +22,7 @@ function composeDeviceConfig(opts) {
 /**
  * @param {DetoxConfigErrorComposer} opts.errorComposer
  * @param {Detox.DetoxConfig} opts.globalConfig
- * @param {Detox.DetoxPlainConfiguration} opts.localConfig
- * @returns {Detox.DetoxDeviceConfig}
- */
-function composeDeviceConfigFromPlain(opts) {
-  const { errorComposer, localConfig } = opts;
-
-  const type = localConfig.type;
-  const device = localConfig.device || localConfig.name;
-  const utilBinaryPaths = localConfig.utilBinaryPaths;
-
-  const deviceConfig = type in EXPECTED_DEVICE_MATCHER_PROPS
-    ? _.omitBy({ type, device, utilBinaryPaths }, _.isUndefined)
-    : { ...localConfig };
-
-  validateDeviceConfig({ deviceConfig, errorComposer });
-
-  return deviceConfig;
-}
-
-/**
- * @param {DetoxConfigErrorComposer} opts.errorComposer
- * @param {Detox.DetoxConfig} opts.globalConfig
- * @param {Detox.DetoxAliasedConfiguration} opts.localConfig
+ * @param {Detox.DetoxConfiguration} opts.localConfig
  * @returns {Detox.DetoxDeviceConfig}
  */
 function composeDeviceConfigFromAliased(opts) {
@@ -145,7 +118,7 @@ function validateDeviceConfig({ deviceConfig, errorComposer, deviceAlias }) {
       throw errorComposer.malformedDeviceProperty(deviceAlias, 'gpuMode');
     }
 
-    if (!deviceConfig.gpuMode.match(/^(auto|host|swiftshader_indirect|angle_indirect|guest)$/)) {
+    if (!deviceConfig.gpuMode.match(/^(auto|host|swiftshader_indirect|angle_indirect|guest|off)$/)) {
       throw errorComposer.malformedDeviceProperty(deviceAlias, 'gpuMode');
     }
 
@@ -159,7 +132,7 @@ function validateDeviceConfig({ deviceConfig, errorComposer, deviceAlias }) {
       throw errorComposer.malformedDeviceProperty(deviceAlias, 'headless');
     }
 
-    if (deviceConfig.type !== 'android.emulator') {
+    if (deviceConfig.type !== 'ios.simulator' && deviceConfig.type !== 'android.emulator') {
       throw errorComposer.unsupportedDeviceProperty(deviceAlias, 'headless');
     }
   }
@@ -176,6 +149,7 @@ function validateDeviceConfig({ deviceConfig, errorComposer, deviceAlias }) {
 
   if (_.isObject(deviceConfig.device)) {
     const expectedProperties = EXPECTED_DEVICE_MATCHER_PROPS[deviceConfig.type];
+    /* istanbul ignore else */
     if (!_.isEmpty(expectedProperties)) {
       const minimalShape = _.pick(deviceConfig.device, expectedProperties);
 
@@ -187,41 +161,44 @@ function validateDeviceConfig({ deviceConfig, errorComposer, deviceAlias }) {
 }
 
 function applyCLIOverrides(deviceConfig, cliConfig) {
-  if (cliConfig.deviceName) {
-    deviceConfig.device = cliConfig.deviceName;
+  _assignCLIConfigIfSupported('device-name', cliConfig.deviceName, deviceConfig, 'device');
+  _assignCLIConfigIfSupported('device-boot-args', cliConfig.deviceBootArgs, deviceConfig, 'bootArgs');
+  _assignCLIConfigIfSupported('headless', cliConfig.headless, deviceConfig, 'headless');
+  _assignCLIConfigIfSupported('force-adb-install', cliConfig.forceAdbInstall, deviceConfig, 'forceAdbInstall');
+  _assignCLIConfigIfSupported('gpu', cliConfig.gpu, deviceConfig, 'gpuMode');
+  _assignCLIConfigIfSupported('readonly-emu', cliConfig.readonlyEmu, deviceConfig, 'readonly');
+}
+
+function _assignCLIConfigIfSupported(argName, argValue, deviceConfig, propertyName) {
+  if (argValue === undefined) {
+    return;
   }
 
   const deviceType = deviceConfig.type;
-  if (cliConfig.deviceBootArgs) {
-    if ((deviceType === 'ios.simulator') || (deviceType === 'android.emulator')) {
-      deviceConfig.bootArgs = cliConfig.deviceBootArgs;
-    } else {
-      log.warn(`--device-boot-args CLI override is not supported by device type = "${deviceType}" and will be ignored`);
-    }
+  const supportedDeviceTypesPrefixes = _supportedDeviceTypesPrefixes(argName);
+  if (!supportedDeviceTypesPrefixes.some((prefix) => deviceType.startsWith(prefix))) {
+    log.warn(`--${argName} CLI override is not supported by device type = "${deviceType}" and will be ignored`);
+    return;
   }
 
-  if (cliConfig.forceAdbInstall !== undefined) {
-    if (deviceType.startsWith('android.')) {
-      deviceConfig.forceAdbInstall = cliConfig.forceAdbInstall;
-    } else {
-      log.warn(`--force-adb-install CLI override is not supported by device type = "${deviceType}" and will be ignored`);
-    }
-  }
+  deviceConfig[propertyName] = argValue;
+}
 
-  const emulatorCLIConfig = _.pick(cliConfig, ['headless', 'gpu', 'readonlyEmu']);
-  const emulatorOverrides = _.omitBy({
-    headless: cliConfig.headless,
-    gpuMode: cliConfig.gpu,
-    readonly: cliConfig.readonlyEmu,
-  }, _.isUndefined);
+function _supportedDeviceTypesPrefixes(argName) {
+  switch (argName) {
+    case 'device-name':
+      return [''];
 
-  if (!_.isEmpty(emulatorOverrides)) {
-    if (deviceType === 'android.emulator') {
-      Object.assign(deviceConfig, emulatorOverrides);
-    } else {
-      const flags = Object.keys(emulatorCLIConfig).map(key => '--' + _.kebabCase(key)).join(', ');
-      log.warn(`${flags} CLI overriding is not supported by device type = "${deviceType}" and will be ignored`);
-    }
+    case 'force-adb-install':
+      return ['android.'];
+
+    case 'gpu':
+    case 'readonly-emu':
+      return ['android.emulator'];
+
+    case 'device-boot-args':
+    case 'headless':
+      return ['ios.simulator', 'android.emulator'];
   }
 }
 
@@ -232,7 +209,6 @@ function unpackDeviceQuery(deviceConfig) {
   }
 
   switch (deviceConfig.type) {
-    case 'ios.none':
     case 'ios.simulator':
       if (_.includes(query, ',')) {
         const [type, os] = _.split(query, /\s*,\s*/);
@@ -252,7 +228,6 @@ function unpackDeviceQuery(deviceConfig) {
 }
 
 const EXPECTED_DEVICE_MATCHER_PROPS = {
-  'ios.none': null,
   'ios.simulator': ['type', 'name', 'id'],
   'android.attached': ['adbName'],
   'android.emulator': ['avdName'],