detox 19.13.0 → 20.0.0

package/src/DetoxWorker.js

@@ -0,0 +1,327 @@
+const CAF = require('caf');
+const _ = require('lodash');
+
+const Client = require('./client/Client');
+const environmentFactory = require('./environmentFactory');
+const { DetoxRuntimeErrorComposer } = require('./errors');
+const { InvocationManager } = require('./invoke');
+const symbols = require('./symbols');
+const AsyncEmitter = require('./utils/AsyncEmitter');
+const uuid = require('./utils/uuid');
+
+class DetoxWorker {
+  constructor(context) {
+    this._context = context;
+    this._injectedGlobalProperties = [];
+    this._config = context[symbols.config];
+    this._runtimeErrorComposer = new DetoxRuntimeErrorComposer(this._config);
+    this._client = null;
+    this._artifactsManager = null;
+    this._eventEmitter = new AsyncEmitter({
+      events: [
+        'bootDevice',
+        'beforeShutdownDevice',
+        'shutdownDevice',
+        'beforeTerminateApp',
+        'terminateApp',
+        'beforeUninstallApp',
+        'beforeLaunchApp',
+        'launchApp',
+        'appReady',
+        'createExternalArtifact',
+      ],
+      onError: this._onEmitError.bind(this),
+    });
+
+
+    /** @type {DetoxInternals.RuntimeConfig['apps']} */
+    this._appsConfig = null;
+    /** @type {DetoxInternals.RuntimeConfig['artifacts']} */
+    this._artifactsConfig = null;
+    /** @type {DetoxInternals.RuntimeConfig['behavior']} */
+    this._behaviorConfig = null;
+    /** @type {DetoxInternals.RuntimeConfig['device']} */
+    this._deviceConfig = null;
+    /** @type {DetoxInternals.RuntimeConfig['session']} */
+    this._sessionConfig = null;
+
+    /** @type {string} */
+    this.id = 'worker';
+    /** @type {Detox.Device} */
+    this.device = null;
+    /** @type {Detox.ElementFacade} */
+    this.element = null;
+    /** @type {Detox.WaitForFacade} */
+    this.waitFor = null;
+    /** @type {Detox.ExpectFacade} */
+    this.expect = null;
+    /** @type {Detox.ByFacade} */
+    this.by = null;
+    /** @type {Detox.WebFacade} */
+    this.web = null;
+
+    this._deviceAllocator = null;
+    this._deviceCookie = null;
+
+    this.trace = this._context.trace;
+    /** @deprecated */
+    this.traceCall = this._context.traceCall;
+
+    this._reinstallAppsOnDevice = CAF(this._reinstallAppsOnDevice.bind(this));
+    this._initToken = new CAF.cancelToken();
+
+    this._cafWrap([
+      'init',
+      'onRunDescribeStart',
+      'onTestStart',
+      'onHookFailure',
+      'onTestFnFailure',
+      'onTestDone',
+      'onRunDescribeFinish',
+    ]);
+  }
+
+  /** @this {DetoxWorker} */
+  init = function* (signal) {
+    const {
+      apps: appsConfig,
+      artifacts: artifactsConfig,
+      behavior: behaviorConfig,
+      device: deviceConfig,
+      session: sessionConfig
+    } = this._config;
+
+    this._appsConfig = appsConfig;
+    this._artifactsConfig = artifactsConfig;
+    this._behaviorConfig = behaviorConfig;
+    this._deviceConfig = deviceConfig;
+    this._sessionConfig = sessionConfig;
+    // @ts-ignore
+    this._sessionConfig.sessionId = sessionConfig.sessionId || uuid.UUID();
+    this._runtimeErrorComposer.appsConfig = this._appsConfig;
+
+    this._client = new Client(sessionConfig);
+    this._client.terminateApp = async () => {
+      // @ts-ignore
+      if (this.device && this.device._isAppRunning()) {
+        await this.device.terminateApp();
+      }
+    };
+
+    yield this._client.connect();
+
+    const invocationManager = new InvocationManager(this._client);
+
+    const {
+      // @ts-ignore
+      envValidatorFactory,
+      deviceAllocatorFactory,
+      // @ts-ignore
+      artifactsManagerFactory,
+      // @ts-ignore
+      matchersFactory,
+      // @ts-ignore
+      runtimeDeviceFactory,
+    } = environmentFactory.createFactories(this._deviceConfig);
+
+    const envValidator = envValidatorFactory.createValidator();
+    yield envValidator.validate();
+
+    const commonDeps = {
+      invocationManager,
+      client: this._client,
+      eventEmitter: this._eventEmitter,
+      runtimeErrorComposer: this._runtimeErrorComposer,
+    };
+
+    this._artifactsManager = artifactsManagerFactory.createArtifactsManager(this._artifactsConfig, commonDeps);
+    this._deviceAllocator = deviceAllocatorFactory.createDeviceAllocator(commonDeps);
+    this._deviceCookie = yield this._deviceAllocator.allocate(this._deviceConfig);
+
+    this.device = runtimeDeviceFactory.createRuntimeDevice(
+      this._deviceCookie,
+      commonDeps,
+      {
+        appsConfig: this._appsConfig,
+        behaviorConfig: this._behaviorConfig,
+        deviceConfig: this._deviceConfig,
+        sessionConfig,
+      });
+
+    const matchers = matchersFactory.createMatchers({
+      invocationManager,
+      runtimeDevice: this.device,
+      eventEmitter: this._eventEmitter,
+    });
+    Object.assign(this, matchers);
+
+    if (behaviorConfig.init.exposeGlobals) {
+      const injectedGlobals = {
+        ...matchers,
+        device: this.device,
+        detox: this,
+      };
+
+      this._injectedGlobalProperties = Object.keys(injectedGlobals);
+      Object.assign(DetoxWorker.global, injectedGlobals);
+    }
+
+    // @ts-ignore
+    yield this.device.installUtilBinaries();
+
+    if (behaviorConfig.init.reinstallApp) {
+      yield this._reinstallAppsOnDevice(signal);
+    }
+
+    const appAliases = Object.keys(this._appsConfig);
+    if (appAliases.length === 1) {
+      yield this.device.selectApp(appAliases[0]);
+    } else {
+      yield this.device.selectApp(null);
+    }
+  };
+
+  async cleanup() {
+    this._initToken.abort('CLEANUP');
+
+    for (const key of this._injectedGlobalProperties) {
+      delete DetoxWorker.global[key];
+    }
+
+    if (this._artifactsManager) {
+      await this._artifactsManager.onBeforeCleanup();
+      this._artifactsManager = null;
+    }
+
+    if (this._client) {
+      this._client.dumpPendingRequests();
+      await this._client.cleanup();
+      this._client = null;
+    }
+
+    if (this.device) {
+      const shutdown = this._behaviorConfig ? this._behaviorConfig.cleanup.shutdownDevice : false;
+      // @ts-ignore
+      await this.device._cleanup();
+      await this._deviceAllocator.free(this._deviceCookie, { shutdown });
+    }
+
+    this._deviceAllocator = null;
+    this._deviceCookie = null;
+    this.device = null;
+  }
+
+  get log() {
+    return this._context.log;
+  }
+
+  onRunDescribeStart = function* (_signal, ...args) {
+    yield this._artifactsManager.onRunDescribeStart(...args);
+  };
+
+  onTestStart = function* (_signal, testSummary) {
+    this._validateTestSummary('beforeEach', testSummary);
+
+    yield this._dumpUnhandledErrorsIfAny({
+      pendingRequests: false,
+      testName: testSummary.fullName,
+    });
+
+    yield this._artifactsManager.onTestStart(testSummary);
+  };
+
+  onHookFailure = function* (_signal, ...args) {
+    yield this._artifactsManager.onHookFailure(...args);
+  };
+
+  onTestFnFailure = function* (_signal, ...args) {
+    yield this._artifactsManager.onTestFnFailure(...args);
+  };
+
+  onTestDone = function* (_signal, testSummary) {
+    this._validateTestSummary('afterEach', testSummary);
+
+    yield this._artifactsManager.onTestDone(testSummary);
+
+    yield this._dumpUnhandledErrorsIfAny({
+      pendingRequests: testSummary.timedOut,
+      testName: testSummary.fullName,
+    });
+  };
+
+  onRunDescribeFinish = function* (_signal, ...args) {
+    yield this._artifactsManager.onRunDescribeFinish(...args);
+  };
+
+  *_reinstallAppsOnDevice(_signal) {
+    const appNames = _(this._appsConfig)
+      .map((config, key) => [key, `${config.binaryPath}:${config.testBinaryPath}`])
+      .uniqBy(1)
+      .map(0)
+      .value();
+
+    for (const appName of appNames) {
+      yield this.device.selectApp(appName);
+      yield this.device.uninstallApp();
+    }
+
+    for (const appName of appNames) {
+      yield this.device.selectApp(appName);
+      yield this.device.installApp();
+    }
+  }
+
+  _validateTestSummary(methodName, testSummary) {
+    if (!_.isPlainObject(testSummary)) {
+      throw this._runtimeErrorComposer.invalidTestSummary(methodName, testSummary);
+    }
+
+    switch (testSummary.status) {
+      case 'running':
+      case 'passed':
+      case 'failed':
+        break;
+      default:
+        throw this._runtimeErrorComposer.invalidTestSummaryStatus(methodName, testSummary);
+    }
+  }
+
+  async _dumpUnhandledErrorsIfAny({ testName, pendingRequests }) {
+    if (pendingRequests) {
+      this._client.dumpPendingRequests({ testName });
+    }
+  }
+
+  _onEmitError({ error, eventName, eventObj }) {
+    this.log.error(
+      { event: 'EMIT_ERROR', fn: eventName },
+      `Caught an exception in: emitter.emit("${eventName}", ${JSON.stringify(eventObj)})\n\n`,
+      error
+    );
+  }
+
+  _cafWrap(methodNames) {
+    for (const methodName of methodNames) {
+      const cafMethod = CAF(this[methodName].bind(this));
+      this[methodName] = async (...args) => {
+        try {
+          await cafMethod(this._initToken.signal, ...args);
+        } catch (e) {
+          if (e !== 'CLEANUP') {
+            throw e;
+          }
+        }
+
+        return this;
+      };
+    }
+  }
+
+}
+
+/**
+ * @type {NodeJS.Global | {}}
+ */
+DetoxWorker.global = global;
+
+module.exports = DetoxWorker;

package/src/android/interactions/native.js

@@ -1,6 +1,7 @@
 const DetoxRuntimeError = require('../../errors/DetoxRuntimeError');
 const { expectDescription, actionDescription } = require('../../utils/invocationTraceDescriptions');
-const { traceInvocationCall } = require('../../utils/trace');
+const log = require('../../utils/logger').child({ cat: 'ws-client, ws' });
+const traceInvocationCall = require('../../utils/traceInvocationCall').bind(null, log);
 const { ScrollAmountStopAtEdgeAction } = require('../actions/native');
 const { NativeMatcher } = require('../core/NativeMatcher');
 const DetoxAssertionApi = require('../espressoapi/DetoxAssertion');

package/src/artifacts/ArtifactsManager.js

@@ -1,24 +1,66 @@
 const EventEmitter = require('events');
 const path = require('path');
-const util = require('util');
 
 const fs = require('fs-extra');
 const _ = require('lodash');
 
 const DetoxRuntimeError = require('../errors/DetoxRuntimeError');
-const log = require('../utils/logger').child({ __filename });
+const log = require('../utils/logger').child({ cat: 'artifacts-manager,artifact' });
+const resolveModuleFromPath = require('../utils/resolveModuleFromPath');
+const traceMethods = require('../utils/traceMethods');
 
 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(log, this, [
+      'onAppReady',
+      'onBeforeCleanup',
+      'onBeforeLaunchApp',
+      'onBeforeShutdownDevice',
+      'onBeforeTerminateApp',
+      'onBeforeUninstallApp',
+      'onBootDevice',
+      'onCreateExternalArtifact',
+      'onHookFailure',
+      'onLaunchApp',
+      'onRunDescribeFinish',
+      'onRunDescribeStart',
+      'onShutdownDevice',
+      'onTerminateApp',
+      'onTestDone',
+      'onTestFnFailure',
+      '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) {
@@ -137,8 +179,6 @@ class ArtifactsManager extends EventEmitter {
     });
   }
 
-  async onRunStart() {}
-
   async onRunDescribeStart(suite) {
     await this._callPlugins('ascending', 'onRunDescribeStart', suite);
   }
@@ -147,22 +187,14 @@ class ArtifactsManager extends EventEmitter {
     await this._callPlugins('ascending', 'onTestStart', testSummary);
   }
 
-  async onHookStart() {}
-
   async onHookFailure(testSummary) {
     await this._callPlugins('plain', 'onHookFailure', testSummary);
   }
 
-  async onHookSuccess() {}
-
-  async onTestFnStart() {}
-
   async onTestFnFailure(testSummary) {
     await this._callPlugins('plain', 'onTestFnFailure', testSummary);
   }
 
-  async onTestFnSuccess() {}
-
   async onTestDone(testSummary) {
     await this._callPlugins('descending', 'onTestDone', testSummary);
   }
@@ -171,35 +203,27 @@ class ArtifactsManager extends EventEmitter {
     await this._callPlugins('descending', 'onRunDescribeFinish', suite);
   }
 
-  async onRunFinish() {}
-
   async onBeforeCleanup() {
     await this._callPlugins('descending', 'onBeforeCleanup');
     await this._idlePromise;
   }
 
   async _callSinglePlugin(pluginId, methodName, ...args) {
-    const callSignature = this._composeCallSignature('artifactsManager', methodName, args);
-    log.trace(Object.assign({ event: 'ARTIFACTS_LIFECYCLE', fn: methodName }, ...args), callSignature);
-
     const plugin = this._artifactPlugins[pluginId];
     try {
       await plugin[methodName](...args);
     } catch (e) {
-      this._unhandledPluginExceptionHandler(e, { plugin, methodName, args });
+      this._unhandledPluginExceptionHandler(e, { plugin, methodName });
     }
   }
 
   async _callPlugins(strategy, methodName, ...args) {
-    const callSignature = this._composeCallSignature('artifactsManager', methodName, args);
-    log.trace(Object.assign({ event: 'ARTIFACTS_LIFECYCLE', fn: methodName }, ...args), callSignature);
-
     for (const pluginGroup of this._groupPlugins(strategy)) {
       await Promise.all(pluginGroup.map(async (plugin) => {
         try {
           await plugin[methodName](...args);
         } catch (e) {
-          this._unhandledPluginExceptionHandler(e, { plugin, methodName, args });
+          this._unhandledPluginExceptionHandler(e, { plugin, methodName });
         }
       }));
     }
@@ -229,28 +253,20 @@ class ArtifactsManager extends EventEmitter {
     }
   }
 
-  _composeCallSignature(object, methodName, args) {
-    const argsString = args.map(arg => util.inspect(arg)).join(', ');
-    return `${object}.${methodName}(${argsString})`;
-  }
-
-  _unhandledPluginExceptionHandler(err, { plugin, methodName, args }) {
+  _unhandledPluginExceptionHandler(err, { plugin, methodName }) {
     const logObject = {
-      event: 'ERROR',
       plugin: plugin.name,
-      err,
       methodName,
+      err,
     };
 
-    const callSignature = this._composeCallSignature(plugin.name, methodName, args);
-    log.warn(logObject, `Suppressed error inside function call: ${callSignature}`);
+    log.warn(logObject, `Suppressed error inside function call.`);
   }
 
   _idleCallbackErrorHandle(err, caller) {
     this._unhandledPluginExceptionHandler(err, {
       plugin: caller,
       methodName: 'onIdleCallback',
-      args: []
     });
   }
 }

package/src/artifacts/instruments/ios/SimulatorInstrumentsRecording.js

@@ -2,7 +2,7 @@
 const fs = require('fs-extra');
 const _ = require('lodash');
 
-const log = require('../../../utils/logger').child({ __filename });
+const log = require('../../../utils/logger').child({ cat: 'artifact' });
 const FileArtifact = require('../../templates/artifact/FileArtifact');
 const InstrumentsArtifactRecording = require('../InstrumentsArtifactRecording');
 
@@ -37,9 +37,9 @@ class SimulatorInstrumentsRecording extends InstrumentsArtifactRecording {
 SimulatorInstrumentsRecording.hintAboutDetoxInstruments = _.once(() => {
   log.warn(`Make sure either:
 1. You have installed Detox Instruments:
-   https://github.com/wix/DetoxInstruments#installation 
+   https://github.com/wix/DetoxInstruments#installation
 2. You have integrated Detox Instruments in your app:
-   https://github.com/wix/DetoxInstruments/blob/master/Documentation/XcodeIntegrationGuide.md 
+   https://github.com/wix/DetoxInstruments/blob/master/Documentation/XcodeIntegrationGuide.md
 3. You have set the environment variable with your custom Detox Instruments location:
    export DETOX_INSTRUMENTS_PATH="/path/to/Detox Instruments.app"`);
 });

package/src/artifacts/log/ios/SimulatorLogRecording.js

@@ -2,7 +2,7 @@
 const fs = require('fs-extra');
 
 const childProcess = require('../../../utils/childProcess');
-const log = require('../../../utils/logger').child({ __filename });
+const log = require('../../../utils/logger').child({ cat: 'artifact' });
 const sleep = require('../../../utils/sleep');
 const Artifact = require('../../templates/artifact/Artifact');
 const FileArtifact = require('../../templates/artifact/FileArtifact');

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/screenshot/SimulatorScreenshotPlugin.js

@@ -1,7 +1,7 @@
 const path = require('path');
 
 const fs = require('../../utils/fsext');
-const log = require('../../utils/logger').child({ __filename });
+const log = require('../../utils/logger').child({ cat: 'artifacts-plugin,artifacts' });
 const FileArtifact = require('../templates/artifact/FileArtifact');
 const temporaryPath = require('../utils/temporaryPath');
 

package/src/artifacts/templates/artifact/Artifact.js

@@ -1,5 +1,5 @@
 // @ts-nocheck
-const log = require('../../../utils/logger').child({ __filename });
+const log = require('../../../utils/logger').child({ cat: 'artifact' });
 
 class Artifact {
   constructor(template) {

package/src/artifacts/templates/plugin/ArtifactPlugin.js

@@ -3,7 +3,7 @@
 
 const _ = require('lodash');
 
-const log = require('../../../utils/logger').child({ __filename });
+const log = require('../../../utils/logger').child({ cat: 'artifacts-plugin,artifacts' });
 
 /***
  * Almost non-opinionated building block for any artifact type

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

@@ -2,13 +2,26 @@ const path = require('path');
 
 const tempfile = require('tempfile');
 
+function createTempFileBuilderFn(fileExtension) {
+  /**
+   * @param {string} [basename]
+   */
+  return (basename) => {
+    return basename
+      ? path.join(path.dirname(tempfile()), `${basename}.detox.${fileExtension}`)
+      : tempfile(`.detox.${fileExtension}`);
+  };
+}
+
 module.exports = {
   for: {
-    png: () => tempfile('.detox.png'),
-    log: () => tempfile('.detox.log'),
-    mp4: () => tempfile('.detox.mp4'),
-    dtxrec: () => tempfile('.detox.dtxrec'),
-    viewhierarchy: () => tempfile('.detox.viewhierarchy'),
+    json: createTempFileBuilderFn('json'),
+    jsonl: createTempFileBuilderFn('jsonl'),
+    png: createTempFileBuilderFn('png'),
+    log: createTempFileBuilderFn('log'),
+    mp4: createTempFileBuilderFn('mp4'),
+    dtxrec: createTempFileBuilderFn('dtxrec'),
+    viewhierarchy: createTempFileBuilderFn('viewhierarchy'),
   },
   mask: () => path.join(tempfile(), '..') + path.sep + '*.detox.*',
 };

package/src/artifacts/video/SimulatorRecordVideoPlugin.js

@@ -1,7 +1,7 @@
 const fs = require('fs-extra');
 
 const { interruptProcess } = require('../../utils/childProcess');
-const log = require('../../utils/logger').child({ __filename });
+const log = require('../../utils/logger').child({ cat: 'artifacts-plugin,artifact' });
 const Artifact = require('../templates/artifact/Artifact');
 const FileArtifact = require('../templates/artifact/FileArtifact');
 const temporaryPath = require('../utils/temporaryPath');