detox 19.13.0 → 20.0.0

package/runners/jest-circus/listeners/DetoxCoreListener.js

@@ -1,113 +0,0 @@
-// @ts-nocheck
-const _ = require('lodash');
-
-const {
-  onRunDescribeStart,
-  onTestStart,
-  onHookFailure,
-  onTestFnFailure,
-  onTestDone,
-  onRunDescribeFinish,
-} = require('../../integration').lifecycle;
-const { getFullTestName, hasTimedOut } = require('../../jest/utils');
-
-const RETRY_TIMES = Symbol.for('RETRY_TIMES');
-
-class DetoxCoreListener {
-  constructor({ detox, env }) {
-    this._startedTests = new WeakSet();
-    this._testsFailedBeforeStart = new WeakSet();
-    this._env = env;
-    this._testRunTimes = 1;
-    this.detox = detox;
-  }
-
-  async run_describe_start({ describeBlock: { name, children } }) {
-    if (children.length) {
-      await this.detox[onRunDescribeStart]({ name });
-    }
-  }
-
-  async run_describe_finish({ describeBlock: { name, children } }) {
-    if (children.length) {
-      await this.detox[onRunDescribeFinish]({ name });
-    }
-  }
-
-  async test_start({ test }) {
-    if (!_.isEmpty(test.errors)) {
-      this._testsFailedBeforeStart.add(test);
-    }
-
-    const circusRetryTimes = +this._env.global[RETRY_TIMES];
-    this._testRunTimes = isNaN(circusRetryTimes) ? 1 : 1 + circusRetryTimes;
-  }
-
-  async hook_start(_event, state) {
-    await this._onBeforeActualTestStart(state.currentlyRunningTest);
-  }
-
-  async hook_failure({ error, hook }) {
-    await this.detox[onHookFailure]({
-      error,
-      hook: hook.type,
-    });
-  }
-
-  async test_fn_start({ test }) {
-    await this._onBeforeActualTestStart(test);
-  }
-
-  async test_fn_failure({ error }) {
-    await this.detox[onTestFnFailure]({ error });
-  }
-
-  async _onBeforeActualTestStart(test) {
-    if (!test || test.status === 'skip' || this._startedTests.has(test) || this._testsFailedBeforeStart.has(test)) {
-      return;
-    }
-
-    this._startedTests.add(test);
-
-    await this.detox[onTestStart]({
-      ...this._getTestMetadata(test),
-      status: 'running',
-    });
-  }
-
-  _getTestMetadata(test) {
-    return {
-      title: test.name,
-      parent: test.parent.name,
-      fullName: getFullTestName(test),
-      functionCode: test.fn.toString(),
-      invocations: this._getTestInvocations(test),
-    };
-  }
-
-  _getTestInvocations(test) {
-    const { DETOX_RERUN_INDEX } = process.env;
-
-    if (!isNaN(DETOX_RERUN_INDEX)) {
-      return Number(DETOX_RERUN_INDEX) * this._testRunTimes + test.invocations;
-    } else {
-      return test.invocations;
-    }
-  }
-
-  async test_done({ test }) {
-    if (this._startedTests.has(test)) {
-      await this.detox[onTestDone]({
-        ...this._getTestMetadata(test),
-        status: _.isEmpty(test.errors) ? 'passed' : 'failed',
-        errors: _.isEmpty(test.errors) ? undefined : test.errors,
-        asyncError: _.isEmpty(test.asyncError) ? undefined : test.asyncError,
-        timedOut: hasTimedOut(test)
-      });
-
-      this._startedTests.delete(test);
-    }
-  }
-}
-
-module.exports = DetoxCoreListener;

package/runners/jest-circus/utils/assertJestCircus26.js

@@ -1,39 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-
-const DetoxRuntimeError = require('../../../src/errors/DetoxRuntimeError');
-
-function assertJestCircus26(maybeProjectConfig) {
-  const projectConfig = maybeProjectConfig.projectConfig || maybeProjectConfig;
-
-  if (!/jest-circus/.test(projectConfig.testRunner)) {
-    throw new DetoxRuntimeError('Cannot run tests without "jest-circus" npm package, exiting.');
-  }
-
-  const circusPackageJson = path.join(path.dirname(projectConfig.testRunner), 'package.json');
-  if (!fs.existsSync(circusPackageJson)) {
-    throw new DetoxRuntimeError('Check that you have an installed copy of "jest-circus" npm package, exiting.');
-  }
-
-  const circusVersion = require(circusPackageJson).version || '';
-  const [major, minor, patch] = circusVersion.split('.');
-  if (major < 26) {
-    throw new DetoxRuntimeError(
-      `Cannot use older versions of "jest-circus", exiting.\n` +
-      `You have jest-circus@${circusVersion}. Update to ^26.0.0 or newer.`
-    );
-  }
-
-  if (major == 26 && minor == 5 && patch < 2) {
-    throw new DetoxRuntimeError(
-      `You have jest-circus@${circusVersion} currently installed.\n` +
-      `Unfortunately, it is incompatible with Detox due to this critical issue:\n\n` +
-      `https://github.com/wix/Detox/issues/2390\n\n` +
-      `Please update to jest-circus@^26.5.2 (or newer) to proceed.`
-    );
-  }
-
-  return maybeProjectConfig;
-}
-
-module.exports = assertJestCircus26;

package/runners/jest-circus/utils/wrapErrorWithNoopLifecycle.js

@@ -1,14 +0,0 @@
-const _ = require('lodash');
-
-const lifecycleSymbols = require('../../integration').lifecycle;
-
-function wrapErrorWithNoopLifecycle(error) {
-  const wrapper = { error };
-  for (const symbol of Object.values(lifecycleSymbols)) {
-    wrapper[symbol] = _.noop;
-  }
-
-  return wrapper;
-}
-
-module.exports = wrapErrorWithNoopLifecycle;

package/src/Detox.js

@@ -1,317 +0,0 @@
-// @ts-nocheck
-const { URL } = require('url');
-const util = require('util');
-
-const _ = require('lodash');
-
-const lifecycleSymbols = require('../runners/integration').lifecycle;
-
-const Client = require('./client/Client');
-const environmentFactory = require('./environmentFactory');
-const { DetoxRuntimeErrorComposer } = require('./errors');
-const { InvocationManager } = require('./invoke');
-const DetoxServer = require('./server/DetoxServer');
-const AsyncEmitter = require('./utils/AsyncEmitter');
-const Deferred = require('./utils/Deferred');
-const MissingDetox = require('./utils/MissingDetox');
-const logger = require('./utils/logger');
-const log = logger.child({ __filename });
-
-const _initHandle = Symbol('_initHandle');
-const _assertNoPendingInit = Symbol('_assertNoPendingInit');
-
-class Detox {
-  constructor(config) {
-    log.trace(
-      { event: 'DETOX_CREATE', config },
-      'created a Detox instance with config:\n%s',
-      util.inspect(_.omit(config, ['errorComposer']), {
-        getters: false,
-        depth: Infinity,
-        maxArrayLength: Infinity,
-        maxStringLength: Infinity,
-        breakLength: false,
-        compact: false,
-      })
-    );
-
-    this[_initHandle] = null;
-
-    for (const [key, symbol] of Object.entries(lifecycleSymbols)) {
-      this[symbol] = (...args) => this._artifactsManager[key](...args);
-    }
-
-    this[lifecycleSymbols.onTestStart] = this.beforeEach;
-    this[lifecycleSymbols.onTestDone] = this.afterEach;
-
-    const { appsConfig, artifactsConfig, behaviorConfig, deviceConfig, sessionConfig } = config;
-
-    this._appsConfig = appsConfig;
-    this._artifactsConfig = artifactsConfig;
-    this._behaviorConfig = behaviorConfig;
-    this._deviceConfig = deviceConfig;
-    this._sessionConfig = sessionConfig;
-    this._runtimeErrorComposer = new DetoxRuntimeErrorComposer({ appsConfig });
-
-    this._client = null;
-    this._server = null;
-    this._artifactsManager = null;
-    this._eventEmitter = new AsyncEmitter({
-      events: [
-        'bootDevice',
-        'beforeShutdownDevice',
-        'shutdownDevice',
-        'beforeTerminateApp',
-        'terminateApp',
-        'beforeUninstallApp',
-        'beforeLaunchApp',
-        'launchApp',
-        'appReady',
-        'createExternalArtifact',
-      ],
-      onError: this._onEmitError.bind(this),
-    });
-
-    this.device = null;
-    this._deviceAllocator = null;
-    this._deviceCookie = null;
-  }
-
-  init() {
-    if (!this[_initHandle]) {
-      this[_initHandle] = new Deferred();
-
-      const { resolve, reject } = this[_initHandle];
-      this._doInit().then(resolve, reject);
-    }
-
-    return this[_initHandle].promise;
-  }
-
-  async cleanup() {
-    await this[_assertNoPendingInit]().catch(_.noop);
-
-    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.cleanup.shutdownDevice;
-      await this.device._cleanup();
-      await this._deviceAllocator.free(this._deviceCookie, { shutdown });
-    }
-
-    if (this._server) {
-      await this._server.close();
-      this._server = null;
-    }
-
-    this._deviceAllocator = null;
-    this._deviceCookie = null;
-    this.device = null;
-  }
-
-  async beforeEach(testSummary) {
-    await this[_assertNoPendingInit]();
-
-    this._validateTestSummary('beforeEach', testSummary);
-    this._logTestRunCheckpoint('DETOX_BEFORE_EACH', testSummary);
-    await this._dumpUnhandledErrorsIfAny({
-      pendingRequests: false,
-      testName: testSummary.fullName,
-    });
-    await this._artifactsManager.onTestStart(testSummary);
-  }
-
-  async afterEach(testSummary) {
-    await this[_assertNoPendingInit]();
-
-    this._validateTestSummary('afterEach', testSummary);
-    this._logTestRunCheckpoint('DETOX_AFTER_EACH', testSummary);
-    await this._artifactsManager.onTestDone(testSummary);
-    await this._dumpUnhandledErrorsIfAny({
-      pendingRequests: testSummary.timedOut,
-      testName: testSummary.fullName,
-    });
-  }
-
-  async _doInit() {
-    const behaviorConfig = this._behaviorConfig.init;
-    const sessionConfig = this._sessionConfig;
-
-    if (sessionConfig.autoStart) {
-      this._server = new DetoxServer({
-        port: sessionConfig.server
-          ? new URL(sessionConfig.server).port
-          : 0,
-        standalone: false,
-      });
-
-      await this._server.open();
-
-      if (!sessionConfig.server) {
-        sessionConfig.server = `ws://localhost:${this._server.port}`;
-      }
-    }
-
-    this._client = new Client(sessionConfig);
-    this._client.terminateApp = async () => {
-      if (this.device && this.device._isAppRunning()) {
-        await this.device.terminateApp();
-      }
-    };
-
-    await this._client.connect();
-
-    const invocationManager = new InvocationManager(this._client);
-
-    const {
-      envValidatorFactory,
-      deviceAllocatorFactory,
-      artifactsManagerFactory,
-      matchersFactory,
-      runtimeDeviceFactory,
-    } = environmentFactory.createFactories(this._deviceConfig);
-
-    const envValidator = envValidatorFactory.createValidator();
-    await 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 = await this._deviceAllocator.allocate(this._deviceConfig);
-
-    this.device = runtimeDeviceFactory.createRuntimeDevice(
-      this._deviceCookie,
-      commonDeps,
-      {
-        appsConfig: this._appsConfig,
-        behaviorConfig: this._behaviorConfig,
-        deviceConfig: this._deviceConfig,
-        sessionConfig,
-      });
-    await this.device._prepare();
-
-    const matchers = matchersFactory.createMatchers({
-      invocationManager,
-      runtimeDevice: this.device,
-      eventEmitter: this._eventEmitter,
-    });
-    Object.assign(this, matchers);
-
-    if (behaviorConfig.exposeGlobals) {
-      Object.assign(Detox.global, {
-        ...matchers,
-        device: this.device,
-      });
-    }
-
-    await this.device.installUtilBinaries();
-    if (behaviorConfig.reinstallApp) {
-      await this._reinstallAppsOnDevice();
-    }
-
-    return this;
-  }
-
-  [_assertNoPendingInit]() {
-    const handle = this[_initHandle];
-    if (!handle) {
-      return Promise.resolve();
-    }
-
-    if (handle.status === Deferred.PENDING) {
-      handle.reject(this._runtimeErrorComposer.abortedDetoxInit());
-    }
-
-    return handle.promise;
-  }
-
-  async _reinstallAppsOnDevice() {
-    const appNames = _(this._appsConfig)
-      .map((config, key) => [key, `${config.binaryPath}:${config.testBinaryPath}`])
-      .uniqBy(1)
-      .map(0)
-      .value();
-
-    for (const appName of appNames) {
-      await this.device.selectApp(appName);
-      await this.device.uninstallApp();
-    }
-
-    for (const appName of appNames) {
-      await this.device.selectApp(appName);
-      await this.device.installApp();
-    }
-
-    if (appNames.length !== 1) {
-      await this.device.selectApp(null);
-    }
-  }
-
-  _logTestRunCheckpoint(event, { status, fullName }) {
-    log.trace({ event, status }, `${status} test: ${JSON.stringify(fullName)}`);
-  }
-
-  _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 }) {
-    log.error(
-      { event: 'EMIT_ERROR', fn: eventName },
-      `Caught an exception in: emitter.emit("${eventName}", ${JSON.stringify(eventObj)})\n\n`,
-      error
-    );
-  }
-
-  static async globalInit(configs) {
-    const handler = await environmentFactory.createGlobalLifecycleHandler(configs.deviceConfig);
-    if (handler) {
-      await handler.globalInit();
-    }
-  }
-
-  static async globalCleanup(configs) {
-    const handler = await environmentFactory.createGlobalLifecycleHandler(configs.deviceConfig);
-    if (handler) {
-      await handler.globalCleanup();
-    }
-  }
-}
-
-Detox.none = new MissingDetox();
-Detox.global = global;
-
-module.exports = Detox;

package/src/DetoxConstants.js

@@ -1,13 +0,0 @@
-module.exports = Object.freeze({
-  'userNotificationTriggers': {
-    'push': 'push',
-    'calendar': 'calendar',
-    'timeInterval': 'timeInterval',
-    'location': 'location'
-  },
-  'userActivityTypes': {
-    'searchableItem': 'com.apple.corespotlightitem',
-    'browsingWeb': 'NSUserActivityTypeBrowsingWeb',
-  },
-  'searchableItemActivityIdentifier': 'kCSSearchableItemActivityIdentifier'
-});

package/src/DetoxExportWrapper.js

@@ -1,140 +0,0 @@
-// @ts-nocheck
-const funpermaproxy = require('funpermaproxy');
-
-const Detox = require('./Detox');
-const DetoxConstants = require('./DetoxConstants');
-const configuration = require('./configuration');
-const logger = require('./utils/logger');
-const log = logger.child({ __filename });
-const { trace, traceCall } = require('./utils/trace');
-
-const _detox = Symbol('detox');
-const _shouldLogInitError = Symbol('shouldLogInitError');
-
-class DetoxExportWrapper {
-  constructor() {
-    this[_detox] = Detox.none;
-    this[_shouldLogInitError] = true;
-
-    this.init = this.init.bind(this);
-    this.cleanup = this.cleanup.bind(this);
-
-    this.DetoxConstants = DetoxConstants;
-
-    this._definePassthroughMethod('beforeEach');
-    this._definePassthroughMethod('afterEach');
-    this._definePassthroughMethod('suiteStart');
-    this._definePassthroughMethod('suiteEnd');
-
-    this._definePassthroughMethod('element');
-    this._definePassthroughMethod('expect');
-    this._definePassthroughMethod('waitFor');
-
-    this._defineProxy('by');
-    this._defineProxy('device');
-    this._defineProxy('web');
-
-    this.trace = trace;
-    this.traceCall = traceCall;
-  }
-
-  async init(configOverride, userParams) {
-    let configError, exposeGlobals, resolvedConfig;
-
-    trace.init();
-    logger.reinitialize(Detox.global);
-
-    try {
-      resolvedConfig = await configuration.composeDetoxConfig({
-        override: configOverride,
-        userParams,
-      });
-
-      exposeGlobals = resolvedConfig.behaviorConfig.init.exposeGlobals;
-    } catch (err) {
-      configError = err;
-      exposeGlobals = true;
-    }
-
-    try {
-      if (exposeGlobals) {
-        Detox.none.initContext(Detox.global);
-      }
-
-      if (configError) {
-        throw configError;
-      }
-
-      this[_detox] = new Detox(resolvedConfig);
-      await traceCall('detoxInit', this[_detox].init());
-      Detox.none.setError(null);
-
-      return this[_detox];
-    } catch (err) {
-      if (this[_shouldLogInitError]) {
-        log.error({ event: 'DETOX_INIT_ERROR' }, '\n', err);
-      }
-
-      Detox.none.setError(err);
-      throw err;
-    }
-  }
-
-  async cleanup() {
-    Detox.none.cleanupContext(Detox.global);
-
-    if (this[_detox] !== Detox.none) {
-      await this[_detox].cleanup();
-      this[_detox] = Detox.none;
-    }
-  }
-
-  _definePassthroughMethod(name) {
-    this[name] = (...args) => {
-      return this[_detox][name](...args);
-    };
-  }
-
-  _defineProxy(name) {
-    this[name] = funpermaproxy(() => this[_detox][name]);
-  }
-
-  /** Use for test runners with sandboxed global */
-  _setGlobal(global) {
-    Detox.global = global;
-    return this;
-  }
-
-  /** @internal */
-  _suppressLoggingInitErrors() {
-    this[_shouldLogInitError] = false;
-    return this;
-  }
-}
-
-DetoxExportWrapper.prototype.hook = configuration.hook;
-
-DetoxExportWrapper.prototype.globalInit = async function() {
-  try {
-    // TODO This can only work in Jest, where config info etc. is available globally through env vars rather
-    //   than argv (e.g. in Mocha) -- which we don't have available here.
-    //   We will resolve this, ultimately, in https://github.com/wix/Detox/issues/2894 (DAS project), where
-    //   this whole hack would be removed altogether.
-    const configs = await configuration.composeDetoxConfig({});
-    await Detox.globalInit(configs);
-  } catch (error) {
-    log.warn({ event: 'GLOBAL_INIT' }, 'An error occurred!');
-    throw error;
-  }
-};
-
-DetoxExportWrapper.prototype.globalCleanup = async function() {
-  try {
-    const configs = await configuration.composeDetoxConfig({});
-    await Detox.globalCleanup(configs);
-  } catch (error) {
-    log.warn({ event: 'GLOBAL_CLEANUP' }, 'An error occurred!', error);
-  }
-};
-
-module.exports = DetoxExportWrapper;