detox 20.14.0-smoke.0 → 20.14.0

package/internals.d.ts

@@ -116,8 +116,9 @@ declare global {
       /**
        * Workaround for Jest exiting abruptly in --bail mode.
        * Makes sure that all workers and their test environments are properly torn down.
+       * @param [permanent] - forbids further retries
        */
-      unsafe_conductEarlyTeardown(): Promise<void>;
+      unsafe_conductEarlyTeardown(permanent?: boolean): Promise<void>;
       /**
        * Reports to Detox CLI about passed and failed test files.
        * The failed test files might be re-run again if

package/jest.config.js

@@ -0,0 +1,108 @@
+const DEBUG = process.argv.includes('--reporters');
+
+/** @type{import('jest-allure2-reporter').ReporterOptions} */
+const jestAllure2ReporterOptions = {
+  testCase: {
+    labels: {
+      package: ({ filePath }) => filePath.slice(1).join('/'),
+      testMethod: ({ testCase }) => testCase.fullName,
+      tag: ['unit'],
+    },
+  },
+};
+
+/** @type {import('@jest/types').Config.InitialOptions} */
+module.exports = {
+  setupFiles: [
+    '<rootDir>/__tests__/setupJest.js'
+  ],
+  testEnvironment: DEBUG ? 'node' : 'jest-allure2-reporter/environment-node',
+  testRunner: 'jest-circus/runner',
+  roots: [
+    'node_modules',
+    'local-cli',
+    'src',
+    'runners'
+  ],
+  testPathIgnorePatterns: [
+    '/node_modules/',
+    'local-cli/test.js'
+  ],
+  coveragePathIgnorePatterns: [
+    '/node_modules/',
+    '__tests__',
+    '.test.js$',
+    '.mock.js$',
+    'index.js',
+    'internals.js',
+    'local-cli/utils',
+    'src/environmentFactory',
+    'src/android/espressoapi',
+    'src/artifacts/factories/index.js',
+    'src/artifacts/providers/index.js',
+    'src/artifacts/log',
+    'src/artifacts/screenshot',
+    'src/artifacts/video',
+    'src/devices/allocation/drivers/android/emulator/launchEmulatorProcess.js',
+    'src/devices/allocation/drivers/android/emulator/patchAvdSkinConfig.js',
+    'src/devices/allocation/.*AllocDriver.js',
+    'src/devices/allocation/drivers/ios',
+    'src/devices/allocation/factories',
+    'src/devices/allocation/factories/drivers',
+    'src/devices/cookies',
+    'src/devices/common/drivers/android/exec/ADB.js',
+    'src/devices/common/drivers/android/emulator/exec/EmulatorExec.js',
+    'src/devices/common/drivers/android/tools/EmulatorTelnet.js',
+    'src/devices/common/drivers/ios/tools',
+    'src/devices/runtime/drivers/android/AndroidDriver.js',
+    'src/devices/runtime/drivers/android/emulator/EmulatorDriver.js',
+    'src/devices/runtime/drivers/DeviceDriverBase.js',
+    'src/devices/runtime/drivers/ios',
+    'src/devices/runtime/factories',
+    'src/devices/runtime/factories/drivers',
+    'src/devices/validation/EnvironmentValidatorBase.js',
+    'src/devices/validation/factories',
+    'src/matchers/factories',
+    'src/utils/appdatapath.js',
+    'src/utils/debug.js',
+    'src/utils/environment.js',
+    'src/utils/logger.js',
+    'src/utils/pipeCommands.js',
+    'src/utils/pressAnyKey.js',
+    'src/utils/shellUtils.js',
+    'runners/jest/reporters',
+    'runners/jest/testEnvironment',
+    'src/DetoxWorker.js',
+    'src/logger/utils/streamUtils.js',
+    'src/realms'
+  ],
+  resetMocks: true,
+  resetModules: true,
+  reporters: [
+    'default',
+    [
+      'jest-allure2-reporter',
+      jestAllure2ReporterOptions,
+    ]
+  ],
+  coverageReporters: [
+    'html',
+    'json',
+    'text',
+    'clover',
+    [
+      'lcov',
+      {
+        projectRoot: '..'
+      }
+    ]
+  ],
+  coverageThreshold: {
+    global: {
+      statements: 100,
+      branches: 100,
+      functions: 100,
+      lines: 100
+    }
+  }
+};

package/local-cli/testCommand/TestRunnerCommand.js

@@ -12,6 +12,7 @@ const { escapeSpaces, useForwardSlashes } = require('../../src/utils/shellUtils'
 const sleep = require('../../src/utils/sleep');
 const AppStartCommand = require('../startCommand/AppStartCommand');
 const { markErrorAsLogged } = require('../utils/cliErrorHandling');
+const interruptListeners = require('../utils/interruptListeners');
 
 const TestRunnerError = require('./TestRunnerError');
 
@@ -28,10 +29,12 @@ class TestRunnerCommand {
     const appsConfig = opts.config.apps;
 
     this._argv = runnerConfig.args;
+    this._detached = runnerConfig.detached;
     this._retries = runnerConfig.retries;
     this._envHint = this._buildEnvHint(opts.env);
     this._startCommands = this._prepareStartCommands(appsConfig, cliConfig);
     this._envFwd = {};
+    this._terminating = false;
 
     if (runnerConfig.forwardEnv) {
       this._envFwd = this._buildEnvOverride(cliConfig, deviceConfig);
@@ -59,16 +62,20 @@ class TestRunnerCommand {
       } catch (e) {
         launchError = e;
 
+        if (this._terminating) {
+          runsLeft = 0;
+        }
+
         const failedTestFiles = detox.session.testResults.filter(r => !r.success);
 
         const { bail } = detox.config.testRunner;
         if (bail && failedTestFiles.some(r => r.isPermanentFailure)) {
-          throw e;
+          runsLeft = 0;
         }
 
         const testFilesToRetry = failedTestFiles.filter(r => !r.isPermanentFailure).map(r => r.testFilePath);
-        if (_.isEmpty(testFilesToRetry)) {
-          throw e;
+        if (testFilesToRetry.length === 0) {
+          runsLeft = 0;
         }
 
         if (--runsLeft > 0) {
@@ -143,6 +150,15 @@ class TestRunnerCommand {
     }, _.isUndefined);
   }
 
+  _onTerminate = () => {
+    if (this._terminating) {
+      return;
+    }
+
+    this._terminating = true;
+    return detox.unsafe_conductEarlyTeardown(true);
+  };
+
   async _spawnTestRunner() {
     const fullCommand = this._buildSpawnArguments().map(escapeSpaces);
     const fullCommandWithHint = printEnvironmentVariables(this._envHint) + fullCommand.join(' ');
@@ -153,6 +169,7 @@ class TestRunnerCommand {
       cp.spawn(fullCommand[0], fullCommand.slice(1), {
         shell: true,
         stdio: 'inherit',
+        detached: this._detached,
         env: _({})
           .assign(process.env)
           .assign(this._envFwd)
@@ -162,6 +179,8 @@ class TestRunnerCommand {
       })
         .on('error', /* istanbul ignore next */ (err) => reject(err))
         .on('exit', (code, signal) => {
+          interruptListeners.unsubscribe(this._onTerminate);
+
           if (code === 0) {
             log.trace.end({ success: true });
             resolve();
@@ -175,6 +194,10 @@ class TestRunnerCommand {
             reject(markErrorAsLogged(error));
           }
         });
+
+      if (this._detached) {
+        interruptListeners.subscribe(this._onTerminate);
+      }
     });
   }
 

package/local-cli/utils/interruptListeners.js

@@ -0,0 +1,15 @@
+function subscribe(listener) {
+  process.on('SIGINT', listener);
+  process.on('SIGTERM', listener);
+}
+
+function unsubscribe(listener) {
+  process.removeListener('SIGINT', listener);
+  process.removeListener('SIGTERM', listener);
+}
+
+module.exports = {
+  subscribe,
+  unsubscribe,
+};
+

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "detox",
   "description": "E2E tests and automation for mobile",
-  "version": "20.14.0-smoke.0",
+  "version": "20.14.0",
   "bin": {
     "detox": "local-cli/cli.js"
   },
@@ -51,7 +51,7 @@
     "eslint-plugin-node": "^11.1.0",
     "eslint-plugin-unicorn": "^47.0.0",
     "jest": "^28.1.3",
-    "jest-allure2-reporter": "^1.2.1",
+    "jest-allure2-reporter": "2.0.0-alpha.11",
     "mockdate": "^2.0.1",
     "prettier": "^2.4.1",
     "react-native": "0.71.10",
@@ -106,104 +106,8 @@
   "engines": {
     "node": ">=14.5.0"
   },
-  "jest": {
-    "setupFiles": [
-      "<rootDir>/__tests__/setupJest.js"
-    ],
-    "testEnvironment": "node",
-    "testRunner": "jest-circus/runner",
-    "roots": [
-      "node_modules",
-      "local-cli",
-      "src",
-      "runners"
-    ],
-    "testPathIgnorePatterns": [
-      "/node_modules/",
-      "local-cli/test.js"
-    ],
-    "coveragePathIgnorePatterns": [
-      "/node_modules/",
-      "__tests__",
-      ".test.js$",
-      ".mock.js$",
-      "index.js",
-      "internals.js",
-      "local-cli/utils",
-      "src/environmentFactory",
-      "src/android/espressoapi",
-      "src/artifacts/factories/index.js",
-      "src/artifacts/providers/index.js",
-      "src/artifacts/log",
-      "src/artifacts/screenshot",
-      "src/artifacts/video",
-      "src/devices/allocation/drivers/android/emulator/launchEmulatorProcess.js",
-      "src/devices/allocation/drivers/android/emulator/patchAvdSkinConfig.js",
-      "src/devices/allocation/.*AllocDriver.js",
-      "src/devices/allocation/drivers/ios",
-      "src/devices/allocation/factories",
-      "src/devices/allocation/factories/drivers",
-      "src/devices/cookies",
-      "src/devices/common/drivers/android/exec/ADB.js",
-      "src/devices/common/drivers/android/emulator/exec/EmulatorExec.js",
-      "src/devices/common/drivers/android/tools/EmulatorTelnet.js",
-      "src/devices/common/drivers/ios/tools",
-      "src/devices/runtime/drivers/android/AndroidDriver.js",
-      "src/devices/runtime/drivers/android/emulator/EmulatorDriver.js",
-      "src/devices/runtime/drivers/DeviceDriverBase.js",
-      "src/devices/runtime/drivers/ios",
-      "src/devices/runtime/factories",
-      "src/devices/runtime/factories/drivers",
-      "src/devices/validation/EnvironmentValidatorBase.js",
-      "src/devices/validation/factories",
-      "src/matchers/factories",
-      "src/utils/appdatapath.js",
-      "src/utils/debug.js",
-      "src/utils/environment.js",
-      "src/utils/logger.js",
-      "src/utils/pipeCommands.js",
-      "src/utils/pressAnyKey.js",
-      "src/utils/shellUtils.js",
-      "runners/jest/reporters",
-      "runners/jest/testEnvironment",
-      "src/DetoxWorker.js",
-      "src/logger/utils/streamUtils.js",
-      "src/realms"
-    ],
-    "resetMocks": true,
-    "resetModules": true,
-    "reporters": [
-      "default",
-      [
-        "jest-allure2-reporter",
-        {
-          "getEnvironmentInfo": false
-        }
-      ]
-    ],
-    "coverageReporters": [
-      "html",
-      "json",
-      "text",
-      "clover",
-      [
-        "lcov",
-        {
-          "projectRoot": ".."
-        }
-      ]
-    ],
-    "coverageThreshold": {
-      "global": {
-        "statements": 100,
-        "branches": 100,
-        "functions": 100,
-        "lines": 100
-      }
-    }
-  },
   "browserslist": [
     "node 14"
   ],
-  "gitHead": "e9ae9173b3e36e9926a74454aa20709ec71d4da8"
+  "gitHead": "4400519a8fdf3adb546766aa869b35f4c407f8e8"
 }

package/runners/jest/reporter.js

@@ -1 +1,21 @@
-module.exports = require('./reporters/DetoxReporter');
+/** @typedef {import('@jest/reporters').Reporter} Reporter */
+
+const {
+  DetoxIPCReporter,
+  DetoxReporterDispatcher,
+  DetoxSummaryReporter,
+  DetoxVerboseReporter,
+} = require('./reporters');
+
+/** @implements {Reporter} */
+class DetoxReporter extends DetoxReporterDispatcher {
+  constructor(globalConfig) {
+    super(globalConfig, {
+      DetoxSummaryReporter,
+      DetoxVerboseReporter,
+      DetoxIPCReporter,
+    });
+  }
+}
+
+module.exports = DetoxReporter;

package/runners/jest/reporters/DetoxIPCReporter.js

@@ -0,0 +1,34 @@
+const { config, reportTestResults } = require('../../../internals');
+
+/** @typedef {import('@jest/reporters').Reporter} Reporter */
+
+/** @implements {Partial<Reporter>} */
+class DetoxIPCReporter {
+  /**
+   * @param {Set<import('@jest/reporters').TestContext>} testContexts
+   * @param {import('@jest/reporters').AggregatedResult} aggregatedResult
+   */
+  async onRunComplete(testContexts, aggregatedResult) {
+    const lostTests = aggregatedResult.numTotalTestSuites - aggregatedResult.testResults.length;
+
+    await reportTestResults(aggregatedResult.testResults.map(r => ({
+      success: !r.failureMessage,
+      testFilePath: r.testFilePath,
+      testExecError: r.testExecError,
+      isPermanentFailure: lostTests > 0 || this._isPermanentFailure(r),
+    })));
+  }
+
+  /**
+   * @param {import('@jest/test-result').TestResult} testResult
+   */
+  _isPermanentFailure(testResult) {
+    if (config.testRunner.jest.retryAfterCircusRetries) {
+      return false;
+    }
+
+    return testResult.testResults.some(r => r.status === 'failed' && r.invocations > 1);
+  }
+}
+
+module.exports = DetoxIPCReporter;

package/runners/jest/reporters/DetoxReporterDispatcher.js

@@ -0,0 +1,144 @@
+/** @typedef {import('@jest/reporters').Reporter} Reporter */
+
+const { config, unsafe_conductEarlyTeardown } = require('../../../internals');
+const Deferred = require('../../../src/utils/Deferred');
+
+/** @implements {Reporter} */
+class DetoxReporterDispatcher {
+  /**
+   * @param {import('@jest/types').Config.GlobalConfig} globalConfig
+   * @param {Record<string, new (globalConfig: import('@jest/types').Config.GlobalConfig) => Partial<Reporter>>} reporters
+   */
+  constructor(globalConfig, reporters) {
+    this._bail = globalConfig.bail;
+    /** @type {Deferred | null} */
+    this._lastRunComplete = null;
+    /** @type {Set<string>} */
+    this._pendingTestFiles = new Set();
+    /** @type {Promise<any> | null} */
+    this._onRunCompletePromise = null;
+    /** @type {Partial<Reporter>[]} */
+    this._reporters = Object.values(reporters).map((Reporter) => new Reporter(globalConfig));
+  }
+
+  getLastError() {
+    for (const reporter of this._reporters) {
+      let error = typeof reporter.getLastError === 'function'
+        ? reporter.getLastError()
+        : undefined;
+
+      if (error) {
+        return error;
+      }
+    }
+
+    return;
+  }
+
+  onRunStart(aggregatedResult, options) {
+    return this._dispatch('onRunStart', aggregatedResult, options);
+  }
+
+  onTestFileStart(test) {
+    this._pendingTestFiles.add(test.path);
+    return this._dispatch(['onTestFileStart', 'onTestStart'], test);
+  }
+
+  onTestStart(test) {
+    // Legacy method
+    return this.onTestFileStart(test);
+  }
+
+  // NEW! Supported only since Jest 29.6.0
+  onTestCaseStart(test, testCaseStartInfo) {
+    return this._dispatch('onTestCaseStart', test, testCaseStartInfo);
+  }
+
+  onTestCaseResult(test, testCaseResult) {
+    return this._dispatch('onTestCaseResult', test, testCaseResult);
+  }
+
+  async onTestFileResult(test, testResult, aggregatedResult) {
+    this._pendingTestFiles.delete(test.path);
+
+    await this._dispatch(['onTestFileResult', 'onTestResult'], test, testResult, aggregatedResult);
+
+    if (this._lastRunComplete && this._pendingTestFiles.size === 0) {
+      this._lastRunComplete.resolve(aggregatedResult);
+    }
+  }
+
+  onTestResult(test, testResult, aggregatedResult) {
+    // Legacy method
+    return this.onTestFileResult(test, testResult, aggregatedResult);
+  }
+
+  onRunComplete(testContexts, aggregatedResult) {
+    if (!this._lastRunComplete) {
+      // Both `_lastRunComplete` and `_onRunCompletePromise` are used to prevent
+      // a bug in Jest, where `onRunComplete` is called multiple times when
+      // Jest runs with `--bail` and multiple workers, and `onRunComplete`
+      // is implemented as an asynchronous long-running operation.
+      this._lastRunComplete = this._pendingTestFiles.size === 0
+        ? Deferred.resolved(aggregatedResult)
+        : new Deferred();
+    }
+
+    if (!this._onRunCompletePromise) {
+      this._onRunCompletePromise = this._doRunComplete(testContexts, aggregatedResult);
+    }
+
+    return this._onRunCompletePromise;
+  }
+
+  /**
+   * @private
+   * @param {Set<import('@jest/reporters').TestContext>} testContexts
+   * @param {import('@jest/test-result').AggregatedResult} aggregatedResult
+   * @returns {Promise<void>}
+   */
+  async _doRunComplete(testContexts, aggregatedResult) {
+    const earlyTeardown = this._bail > 0 && aggregatedResult.numFailedTests >= this._bail;
+    if (earlyTeardown) {
+      const lostTests = aggregatedResult.numTotalTestSuites - aggregatedResult.testResults.length;
+      if (lostTests > 0 && config.testRunner.retries > 0) {
+        console.warn(
+          'Jest aborted the test execution before all scheduled test files have been reported.\n' +
+          'If you want to retry the whole test run, please disable Jest\'s --bail option.'
+        );
+      }
+
+      await unsafe_conductEarlyTeardown();
+    }
+
+    await this._lastRunComplete.promise;
+    await this._dispatch('onRunComplete', testContexts, aggregatedResult);
+  }
+
+  /**
+   * @private
+   * @param {string | string[]} rawMethodNames
+   * @param {...any} args
+   * @returns {Promise<void>}
+   */
+  _dispatch(rawMethodNames, ...args) {
+    const methodNames = Array.isArray(rawMethodNames)
+      ? rawMethodNames
+      : [rawMethodNames];
+
+    const maybePromises = [];
+
+    for (const reporter of this._reporters) {
+      for (const methodName of methodNames) {
+        if (typeof reporter[methodName] === 'function') {
+          maybePromises.push(reporter[methodName](...args));
+          break;
+        }
+      }
+    }
+
+    return Promise.all(maybePromises).then(() => void 0);
+  }
+}
+
+module.exports = DetoxReporterDispatcher;

package/runners/jest/reporters/DetoxSummaryReporter.js

@@ -0,0 +1,16 @@
+/** @typedef {import('@jest/reporters').Reporter} Reporter */
+
+const resolveFrom = require('resolve-from');
+/** @type {new (globalConfig: any) => import('@jest/reporters').SummaryReporter} */
+const SummaryReporter = require(resolveFrom(process.cwd(), '@jest/reporters')).SummaryReporter;
+
+/** @implements {Partial<Reporter>} */
+class DetoxSummaryReporter {
+  constructor(globalConfig) {
+    if (globalConfig.reporters.every(([name]) => name !== 'default' && name !== 'summary')) {
+      return new SummaryReporter(globalConfig);
+    }
+  }
+}
+
+module.exports = DetoxSummaryReporter;

package/runners/jest/reporters/DetoxVerboseReporter.js

@@ -0,0 +1,16 @@
+/** @typedef {import('@jest/reporters').Reporter} Reporter */
+
+const resolveFrom = require('resolve-from');
+/** @type {new (globalConfig: any) => import('@jest/reporters').VerboseReporter} */
+const VerboseReporter = require(resolveFrom(process.cwd(), '@jest/reporters')).VerboseReporter;
+
+/** @implements {Partial<Reporter>} */
+class DetoxVerboseReporter {
+  constructor(globalConfig) {
+    if (globalConfig.reporters.every(([name]) => name !== 'default')) {
+      return new VerboseReporter(globalConfig);
+    }
+  }
+}
+
+module.exports = DetoxVerboseReporter;

package/runners/jest/reporters/index.js

@@ -0,0 +1,6 @@
+module.exports = {
+  DetoxIPCReporter: require('./DetoxIPCReporter'),
+  DetoxReporterDispatcher: require('./DetoxReporterDispatcher'),
+  DetoxSummaryReporter: require('./DetoxSummaryReporter'),
+  DetoxVerboseReporter: require('./DetoxVerboseReporter'),
+};

package/runners/jest/testEnvironment/index.js

@@ -73,7 +73,9 @@ class DetoxCircusEnvironment extends NodeEnvironment {
   // @ts-expect-error TS2425
   async handleTestEvent(event, state) {
     if (detox.session.unsafe_earlyTeardown) {
-      throw new Error('Detox halted test execution due to an early teardown request');
+      if (event.name === 'test_fn_start' || event.name === 'hook_start') {
+        throw new Error('Detox halted test execution due to an early teardown request');
+      }
     }
 
     this._timer.schedule(state.testTimeout != null ? state.testTimeout : this.setupTimeout);
@@ -107,6 +109,10 @@ class DetoxCircusEnvironment extends NodeEnvironment {
    * @protected
    */
   async initDetox() {
+    if (detox.session.unsafe_earlyTeardown) {
+      throw new Error('Detox halted test execution due to an early teardown request');
+    }
+
     const opts = {
       global: this.global,
       workerId: `w${process.env.JEST_WORKER_ID}`,

package/src/android/core/WebElement.js

@@ -1,5 +1,7 @@
 const DetoxRuntimeError = require('../../errors/DetoxRuntimeError');
 const invoke = require('../../invoke');
+const assertIsFunction = require('../../utils/assertIsFunction');
+const isArrowFunction = require('../../utils/isArrowFunction');
 const actions = require('../actions/web');
 const EspressoWebDetoxApi = require('../espressoapi/web/EspressoWebDetox');
 const WebViewElementApi = require('../espressoapi/web/WebViewElement');
@@ -73,12 +75,14 @@ class WebElement {
     return await new ActionInteraction(this[_invocationManager], new actions.WebMoveCursorEnd(this)).execute();
   }
 
-  async runScript(script) {
-    return await new ActionInteraction(this[_invocationManager], new actions.WebRunScriptAction(this, script)).execute();
-  }
+  async runScript(maybeFunction, args) {
+    const script = stringifyScript(maybeFunction);
 
-  async runScriptWithArgs(script, args) {
-    return await new ActionInteraction(this[_invocationManager], new actions.WebRunScriptWithArgsAction(this, script, args)).execute();
+    if (args) {
+      return await new ActionInteraction(this[_invocationManager], new actions.WebRunScriptWithArgsAction(this, script, args)).execute();
+    } else {
+      return await new ActionInteraction(this[_invocationManager], new actions.WebRunScriptAction(this, script)).execute();
+    }
   }
 
   async getCurrentUrl() {
@@ -116,10 +120,24 @@ class WebViewElement {
       });
     }
 
-    throw new DetoxRuntimeError(`element() argument is invalid, expected a web matcher, but got ${typeof element}`);
+    throw new DetoxRuntimeError(`element() argument is invalid, expected a web matcher, but got ${typeof webMatcher}`);
   }
 }
 
+function stringifyScript(maybeFunction) {
+  if (typeof maybeFunction !== 'string' && typeof maybeFunction !== 'function') {
+    return maybeFunction;
+  }
+
+  const script = (typeof maybeFunction === 'function' ? maybeFunction.toString() : assertIsFunction(maybeFunction)).trim();
+  // WebElement interactions don't support arrow functions for some reason.
+  if (isArrowFunction(script)) {
+    return `function arrowWorkaround() { return (${script}).apply(this, arguments); }`;
+  }
+
+  return script;
+}
+
 module.exports = {
   WebElement,
   WebViewElement,

package/src/android/espressoapi/web/WebElement.js

@@ -76,10 +76,7 @@ class WebElement {
     return {
       target: element,
       method: "runScriptWithArgs",
-      args: [script, {
-        type: "ArrayList<Object>",
-        value: args
-      }]
+      args: [script, args]
     };
   }