detox 19.13.0 → 20.0.0

package/src/client/AsyncWebSocket.js

@@ -5,25 +5,16 @@ 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({ cat: 'ws-client,ws' });
 
 const InflightRequest = require('./InflightRequest');
 
-const EVENTS = {
-  OPEN: Object.freeze({ event: 'WS_OPEN' }),
-  ERROR: Object.freeze({ event: 'WS_ERROR' }),
-  MESSAGE: Object.freeze({ event: 'WS_MESSAGE' }),
-  SEND: Object.freeze({ event: 'WS_SEND' }),
-  LATE_RESPONSE: Object.freeze({ event: 'WS_LATE_RESPONSE' }),
-};
-
 const DEFAULT_SEND_OPTIONS = {
   timeout: 0,
 };
 
 class AsyncWebSocket {
   constructor(url) {
-    this._log = log.child({ url });
     this._url = url;
     this._ws = null;
     this._eventCallbacks = {};
@@ -99,9 +90,9 @@ class AsyncWebSocket {
 
     this.handleMultipleNonAtomicPendingActions();
 
-    const messageAsString = JSON.stringify(message);
-    this._log.trace(EVENTS.SEND, messageAsString);
-    this._ws.send(messageAsString);
+    const payload = JSON.stringify(message);
+    log.trace({ data: payload }, 'send message');
+    this._ws.send(payload);
 
     return inFlight.promise;
   }
@@ -157,7 +148,7 @@ class AsyncWebSocket {
     }
 
     if (!hasPendingActions) {
-      log.error(EVENTS.ERROR, DetoxRuntimeError.format(error));
+      log.error({ error });
     }
   }
 
@@ -186,7 +177,7 @@ class AsyncWebSocket {
    * @private
    */
   _onOpen(event) { // eslint-disable-line no-unused-vars
-    this._log.trace(EVENTS.OPEN, `opened web socket to: ${this._url}`);
+    log.trace(`opened web socket to: ${this._url}`);
     this._opening.resolve();
     this._opening = null;
   }
@@ -234,7 +225,7 @@ class AsyncWebSocket {
     const data = event && event.data || null;
 
     try {
-      this._log.trace(EVENTS.MESSAGE, data);
+      log.trace({ data }, 'get message');
 
       const json = JSON.parse(data);
       if (!json || !json.type) {
@@ -259,7 +250,7 @@ class AsyncWebSocket {
 
       if (!handled) {
         if (this._abortedMessageIds.has(json.messageId)) {
-          log.debug(EVENTS.LATE_RESPONSE, `Received late response for messageId=${json.messageId}`);
+          log.debug({ messageId: json.messageId }, `late response`);
         } else {
           throw new DetoxRuntimeError('Unexpected message received over the web socket: ' + json.type);
         }

package/src/client/Client.js

@@ -9,7 +9,7 @@ const DetoxRuntimeError = require('../errors/DetoxRuntimeError');
 const failedToReachTheApp = require('../errors/longreads/failedToReachTheApp');
 const Deferred = require('../utils/Deferred');
 const { asError, createErrorWithUserStack, replaceErrorStack } = require('../utils/errorUtils');
-const log = require('../utils/logger').child({ __filename });
+const log = require('../utils/logger').child({ cat: 'ws-client,ws' });
 
 const AsyncWebSocket = require('./AsyncWebSocket');
 const actions = require('./actions/actions');

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

@@ -1,9 +1,6 @@
 const _ = require('lodash');
 
 const argparse = require('../utils/argparse');
-const log = require('../utils/logger').child({ __filename });
-
-const { DEVICE_LAUNCH_ARGS_GENERIC_DEPRECATION } = require('./utils/warnings');
 
 const asBoolean = (value) => {
   if (typeof value === 'boolean') {
@@ -25,18 +22,10 @@ const asNumber = (value) => {
     : undefined;
 };
 
-const deprecateDeviceLaunchArgs = (value) => {
-  if (value) {
-    log.warn(DEVICE_LAUNCH_ARGS_GENERIC_DEPRECATION);
-  }
-
-  return 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,12 +36,11 @@ 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'),
     debugSynchronization: asNumber(get('debug-synchronization')),
-    deviceBootArgs: get('device-boot-args', deprecateDeviceLaunchArgs(argparse.getEnvValue('device-launch-args'))),
+    deviceBootArgs: get('device-boot-args'),
     appLaunchArgs: get('app-launch-args'),
     deviceName: get('device-name'),
     forceAdbInstall: asBoolean(get('force-adb-install')),
@@ -64,9 +52,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

@@ -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) {
@@ -202,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/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

@@ -2,7 +2,7 @@
 const _ = require('lodash');
 
 const environmentFactory = require('../environmentFactory');
-const log = require('../utils/logger').child({ __filename });
+const log = require('../utils/logger').child({ cat: 'config' });
 
 /**
  * @param {DetoxConfigErrorComposer} opts.errorComposer
@@ -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'],

package/src/configuration/composeLoggerConfig.js

@@ -0,0 +1,59 @@
+const _ = require('lodash');
+
+const { castLevel, defaultOptions } = require('../logger/DetoxLogger');
+
+/**
+ * @param {object} opts
+ * @param {Detox.DetoxConfig} opts.globalConfig
+ * @param {Detox.DetoxConfiguration} opts.localConfig
+ * @param {*} opts.cliConfig
+ */
+function composeLoggerConfig(opts) {
+  const { globalConfig, localConfig, cliConfig } = opts;
+
+  const items = [
+    {
+      level: 'info',
+      overrideConsole: true,
+      options: defaultOptions,
+    },
+    globalConfig.logger,
+    localConfig.logger,
+    adaptCLI(cliConfig),
+  ];
+
+  return items.reduce(
+    /**
+     * @param {Partial<Detox.DetoxLoggerConfig>} acc
+     * @param config
+     */
+    (acc, config) => {
+      if (!config) return acc;
+      const { options } = config;
+      return _.merge(acc, {
+        options: typeof options === 'function' ? options(acc) : options
+      });
+    },
+    items.reduce((a, b) => _.merge(a, _.omit(b, 'options')))
+  );
+}
+
+function adaptCLI(cliConfig) {
+  const result = {};
+
+  if (cliConfig.loglevel !== undefined) {
+    result.level = castLevel(cliConfig.loglevel);
+  }
+
+  if (cliConfig.useCustomLogger !== undefined) {
+    result.overrideConsole = cliConfig.useCustomLogger;
+  }
+
+  if (cliConfig.noColor) {
+    result.options = { colors: false };
+  }
+
+  return result;
+}
+
+module.exports = composeLoggerConfig;