detox 20.0.5-breaking.new-global-lifecycle.0 → 20.0.8-prerelease.0

package/android/detox/src/full/java/com/wix/detox/reactnative/idlingresources/timers/IdleInterrogationStrategy.kt

@@ -1,6 +1,5 @@
 package com.wix.detox.reactnative.idlingresources.timers
 
-import android.util.Log
 import com.facebook.react.bridge.ReactContext
 import com.wix.detox.common.UIThread
 import java.util.concurrent.Callable
@@ -13,14 +12,5 @@ fun getInterrogationStrategy(reactContext: ReactContext): IdleInterrogationStrat
     // Getting a native-module (inside) also initializes it if needed. That has to run on a
     // looper thread, and the easiest to make sure that happens is to use the main thread.
     UIThread.runSync(Callable {
-        DelegatedIdleInterrogationStrategy.createIfSupported(reactContext)?.let {
-            return@Callable it
-        }
-
-        DefaultIdleInterrogationStrategy.createIfSupported(reactContext)?.let {
-            return@Callable it
-        }
-
-        Log.e(TimersIdlingResource.LOG_TAG, "Failed to determine proper implementation-strategy for timers idling resource")
-        null
+        return@Callable DelegatedIdleInterrogationStrategy.create(reactContext)
     })

package/android/detox/src/testFull/java/com/wix/detox/espresso/action/DetoxMultiTapSpec.kt

@@ -11,6 +11,7 @@ import org.assertj.core.api.Assertions.assertThat
 import org.mockito.kotlin.*
 import org.spekframework.spek2.Spek
 import org.spekframework.spek2.style.specification.describe
+import java.lang.NullPointerException
 import kotlin.test.assertFailsWith
 
 object DetoxMultiTapSpec: Spek({
@@ -136,17 +137,17 @@ object DetoxMultiTapSpec: Spek({
         }
 
         it("should throw if no UI-controller provided") {
-            assertFailsWith(KotlinNullPointerException::class) {
+            assertFailsWith(NullPointerException::class) {
                 uut(1).sendTap(null, coordinates, precision, -1, -1)
             }
         }
 
         it("should throw if no coordinates / precision are provided") {
-            assertFailsWith(KotlinNullPointerException::class) {
+            assertFailsWith(NullPointerException::class) {
                 uut(1).sendTap(uiController, null, precision, -1, -1)
             }
 
-            assertFailsWith(KotlinNullPointerException::class) {
+            assertFailsWith(NullPointerException::class) {
                 uut(1).sendTap(uiController, coordinates, null, -1, -1)
             }
         }

package/android/detox/src/testFull/java/com/wix/detox/reactnative/idlingresources/timers/DelegatedIdleInterrogationStrategySpec.kt

@@ -5,22 +5,14 @@ import org.assertj.core.api.Assertions.assertThat
 import org.mockito.kotlin.*
 import org.spekframework.spek2.Spek
 import org.spekframework.spek2.style.specification.describe
+import com.facebook.react.modules.core.TimingModule
 
 private const val BUSY_INTERVAL_MS = 1500L
 
-abstract class TimingModuleStub: NativeModule {
-    abstract fun hasActiveTimersInRange(rangeMs: Long): Boolean
-
-    override fun onCatalystInstanceDestroy() {}
-    override fun getName(): String = "TimersNativeModuleStub"
-    override fun canOverrideExistingModule() = false
-    override fun initialize() {}
-}
-
 object DelegatedIdleInterrogationStrategySpec : Spek({
-    describe("RN62+ timers idle-interrogation strategy") {
+    describe("Timers idle-interrogation strategy") {
 
-        lateinit var timingModule: TimingModuleStub
+        lateinit var timingModule: TimingModule
 
         beforeEachTest {
             timingModule = mock()

package/index.d.ts

@@ -157,6 +157,17 @@ declare global {
              * Use it when you rely on another test runner than Jest.
              */
             inspectBrk?: boolean | ((config: DetoxTestRunnerConfig) => void);
+            /**
+             * Forward environment variables to the spawned test runner
+             * accordingly to the given CLI argument overrides.
+             *
+             * If false, Detox CLI will be only printing a hint message on
+             * how to start the test runner using environment variables,
+             * in case when a user wants to avoid using Detox CLI.
+             *
+             * @default false
+             */
+            forwardEnv?: boolean;
         }
 
         type DetoxAppConfig = (DetoxBuiltInAppConfig | DetoxCustomAppConfig) & {
@@ -353,12 +364,21 @@ declare global {
                 readonly startSection: (name: string) => void;
                 /** @deprecated */
                 readonly endSection: (name: string) => void;
+                /** @private */
+                readonly invocationCall: (...args: unknown[]) => unknown;
             };
 
             /**
+             * Trace a single call, with a given name and arguments.
+             *
              * @deprecated
+             * @param sectionName The name of the section to trace.
+             * @param promiseOrFunction Promise or a function that provides a promise.
+             * @param args Optional arguments to pass to the trace.
+             * @returns The returned value of the traced call.
+             * @see https://wix.github.io/Detox/docs/next/api/detox-object-api/#detoxtracecall.
              */
-            readonly traceCall: <T>(event: string, action: () => Promise<T>) => Promise<T>;
+            readonly traceCall: <T>(event: string, action: () => Promise<T>, args?: Record<string, unknown>) => Promise<T>;
         }
 
         interface Logger {

package/local-cli/test.js

@@ -9,16 +9,21 @@ module.exports.middlewares = require('./testCommand/middlewares').default;
 
 module.exports.handler = async function test({ detoxArgs, runnerArgs }) {
   try {
-    await detox.init({
+    const opts = {
       argv: detoxArgs,
       testRunnerArgv: runnerArgs,
       workerId: null,
-    });
+    };
+
+    const config = await detox.resolveConfig(opts);
+    if (!config.testRunner.inspectBrk) {
+      await detox.init(opts);
+    }
 
     const runnerCommand = new TestRunnerCommand()
-      .setRunnerConfig(detox.config.testRunner)
       .setDeviceConfig(detox.config.device)
-      .replicateCLIConfig(detox.config.cli);
+      .replicateCLIConfig(detox.config.cli)
+      .setRunnerConfig(detox.config.testRunner);
 
     await runnerCommand.execute();
   } finally {

package/local-cli/testCommand/TestRunnerCommand.js

@@ -36,9 +36,8 @@ class TestRunnerCommand {
    */
   setRunnerConfig(config) {
     this._argv = config.args;
-    this._retries = config.retries;
-
-    if (config.inspectBrk === true) {
+    this._retries = config.inspectBrk ? 0 : config.retries;
+    if (config.inspectBrk || config.forwardEnv) {
       this._env = this._envHint;
     }
 
@@ -105,11 +104,13 @@ class TestRunnerCommand {
           throw e;
         }
 
-        this._argv._ = testFilesToRetry.splice(0, Infinity);
-        // @ts-ignore
-        detox.session.testSessionIndex++; // it is always a primary context, so we can update it
+        if (--runsLeft > 0) {
+          this._argv._ = testFilesToRetry.splice(0, Infinity);
+          // @ts-ignore
+          detox.session.testSessionIndex++; // it is always a primary context, so we can update it
+        }
       }
-    } while (launchError && --runsLeft > 0);
+    } while (launchError && runsLeft > 0);
 
     if (launchError) {
       throw launchError;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "detox",
   "description": "E2E tests and automation for mobile",
-  "version": "20.0.5-breaking.new-global-lifecycle.0",
+  "version": "20.0.8-prerelease.0",
   "bin": {
     "detox": "local-cli/cli.js"
   },
@@ -49,7 +49,7 @@
     "jest": "^28.0.0",
     "mockdate": "^2.0.1",
     "prettier": "1.7.0",
-    "react-native": "0.68.2",
+    "react-native": "0.69.5",
     "react-native-codegen": "^0.0.8",
     "typescript": "^4.5.2",
     "wtfnode": "^0.9.1"
@@ -184,5 +184,5 @@
       }
     }
   },
-  "gitHead": "e299576e350a493084cf00a3007e5dd1ae03c3d5"
+  "gitHead": "205099aa94b9c7c5e0fa47985e24255f8aee3b1b"
 }

package/runners/jest/testEnvironment/index.js

@@ -1,5 +1,6 @@
-// @ts-nocheck
-const maybeNodeEnvironment = require('jest-environment-node'); // eslint-disable-line node/no-extraneous-require
+const resolveFrom = require('resolve-from');
+const maybeNodeEnvironment = require(resolveFrom(process.cwd(), 'jest-environment-node'));
+// @ts-ignore
 const NodeEnvironment = maybeNodeEnvironment.default || maybeNodeEnvironment;
 
 const detox = require('../../../internals');
@@ -129,7 +130,7 @@ class DetoxCircusEnvironment extends NodeEnvironment {
   async initDetox() {
     const opts = {
       global: this.global,
-      workerId: `worker-${process.env.JEST_WORKER_ID}`,
+      workerId: `w${process.env.JEST_WORKER_ID}`,
     };
 
     if (this._shouldManageDetox) {

package/src/DetoxWorker.js

@@ -195,7 +195,6 @@ class DetoxWorker {
   onTestStart = async (testSummary) => {
     if (this._isCleaningUp) return;
     this._validateTestSummary('beforeEach', testSummary);
-    this._logTestRunCheckpoint('DETOX_BEFORE_EACH', testSummary);
 
     if (this._isCleaningUp) return;
     await this._dumpUnhandledErrorsIfAny({
@@ -215,7 +214,6 @@ class DetoxWorker {
   onTestDone = async (testSummary) => {
     if (this._isCleaningUp) return;
     this._validateTestSummary('afterEach', testSummary);
-    this._logTestRunCheckpoint('DETOX_AFTER_EACH', testSummary);
 
     if (this._isCleaningUp) return;
     await this._artifactsManager.onTestDone(testSummary);
@@ -251,10 +249,6 @@ class DetoxWorker {
     }
   }
 
-  _logTestRunCheckpoint(event, { status, fullName }) {
-    this.log.trace({ event, status }, `${status} test: ${JSON.stringify(fullName)}`);
-  }
-
   _validateTestSummary(methodName, testSummary) {
     if (!_.isPlainObject(testSummary)) {
       throw this._runtimeErrorComposer.invalidTestSummary(methodName, testSummary);

package/src/android/core/NativeElement.js

@@ -5,6 +5,7 @@ const tempfile = require('tempfile');
 
 const DetoxRuntimeError = require('../../errors/DetoxRuntimeError');
 const invoke = require('../../invoke');
+const { actionDescription } = require('../../utils/invocationTraceDescriptions');
 const actions = require('../actions/native');
 const DetoxMatcherApi = require('../espressoapi/DetoxMatcher');
 const { ActionInteraction } = require('../interactions/native');
@@ -18,12 +19,11 @@ class NativeElement {
   }
 
   _selectElementWithMatcher(matcher) {
-    // if (!(matcher instanceof NativeMatcher)) throw new DetoxRuntimeError(`Element _selectElementWithMatcher argument must be a valid NativeMatcher, got ${typeof matcher}`);
     this._call = invoke.call(invoke.Espresso, 'onView', matcher._call);
   }
 
   atIndex(index) {
-    if (typeof index !== 'number') throw new DetoxRuntimeError(`Element atIndex argument must be a number, got ${typeof index}`);
+    if (typeof index !== 'number') throw new DetoxRuntimeError({ message: `Element atIndex argument must be a number, got ${typeof index}` });
     const matcher = this._originalMatcher;
     this._originalMatcher._call = invoke.callDirectly(DetoxMatcherApi.matcherForAtIndex(index, matcher._call.value));
 
@@ -32,56 +32,84 @@ class NativeElement {
   }
 
   async tap(value) {
-    return await new ActionInteraction(this._invocationManager, this, new actions.TapAction(value)).execute();
+    const action = new actions.TapAction(value);
+    const traceDescription = actionDescription.tapAtPoint(value);
+    return await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
   }
 
   async tapAtPoint(value) {
-    return await new ActionInteraction(this._invocationManager, this, new actions.TapAtPointAction(value)).execute();
+    const action = new actions.TapAtPointAction(value);
+    const traceDescription = actionDescription.tapAtPoint(value);
+    return await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
   }
 
   async longPress() {
-    return await new ActionInteraction(this._invocationManager, this, new actions.LongPressAction()).execute();
+    const action = new actions.LongPressAction();
+    const traceDescription = actionDescription.longPress();
+    return await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
   }
 
   async multiTap(times) {
-    return await new ActionInteraction(this._invocationManager, this, new actions.MultiClickAction(times)).execute();
+    if (typeof times !== 'number') throw new Error('times should be a number, but got ' + (times + (' (' + (typeof times + ')'))));
+    if (times < 1) throw new Error('times should be greater than 0, but got ' + times);
+
+    const action = new actions.MultiClickAction(times);
+    const traceDescription = actionDescription.multiTap(times);
+    return await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
   }
 
   async tapBackspaceKey() {
-    return await new ActionInteraction(this._invocationManager, this, new actions.PressKeyAction(67)).execute();
+    const action = new actions.PressKeyAction(67);
+    const traceDescription = actionDescription.tapBackspaceKey();
+    return await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
   }
 
   async tapReturnKey() {
-    return await new ActionInteraction(this._invocationManager, this, new actions.TypeTextAction('\n')).execute();
+    const action = new actions.TypeTextAction('\n');
+    const traceDescription = actionDescription.tapReturnKey();
+    return await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
   }
 
   async typeText(value) {
-    return await new ActionInteraction(this._invocationManager, this, new actions.TypeTextAction(value)).execute();
+    const action = new actions.TypeTextAction(value);
+    const traceDescription = actionDescription.typeText(value);
+    return await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
   }
 
   async replaceText(value) {
-    return await new ActionInteraction(this._invocationManager, this, new actions.ReplaceTextAction(value)).execute();
+    const action = new actions.ReplaceTextAction(value);
+    const traceDescription = actionDescription.replaceText(value);
+    return await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
   }
 
   async clearText() {
-    return await new ActionInteraction(this._invocationManager, this, new actions.ClearTextAction()).execute();
+    const action = new actions.ClearTextAction();
+    const traceDescription = actionDescription.clearText();
+    return await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
   }
 
   async scroll(amount, direction = 'down', startPositionX, startPositionY) {
-    // override the user's element selection with an extended matcher that looks for UIScrollView children
-    // this._selectElementWithMatcher(this._originalMatcher._extendToDescendantScrollViews());
-    return await new ActionInteraction(this._invocationManager, this, new actions.ScrollAmountAction(direction, amount, startPositionX, startPositionY)).execute();
+    const action = new actions.ScrollAmountAction(direction, amount, startPositionX, startPositionY);
+    const traceDescription = actionDescription.scroll(amount, direction, startPositionX, startPositionY);
+    return await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
   }
 
   async scrollTo(edge) {
     // override the user's element selection with an extended matcher that looks for UIScrollView children
     this._selectElementWithMatcher(this._originalMatcher._extendToDescendantScrollViews());
-    return await new ActionInteraction(this._invocationManager, this, new actions.ScrollEdgeAction(edge)).execute();
+
+    const action = new actions.ScrollEdgeAction(edge);
+    const traceDescription = actionDescription.scrollTo(edge);
+    return await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
   }
 
   async scrollToIndex(index) {
+    // override the user's element selection with an extended matcher that looks for UIScrollView children
     this._selectElementWithMatcher(this._originalMatcher._extendToDescendantScrollViews());
-    return await new ActionInteraction(this._invocationManager, this, new actions.ScrollToIndex(index)).execute();
+
+    const action = new actions.ScrollToIndex(index);
+    const traceDescription = actionDescription.scrollToIndex(index);
+    return await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
   }
 
   /**
@@ -96,13 +124,17 @@ class NativeElement {
 
     // override the user's element selection with an extended matcher that avoids RN issues with RCTScrollView
     this._selectElementWithMatcher(this._originalMatcher._avoidProblematicReactNativeElements());
+
     const action = new actions.SwipeAction(direction, speed, normalizedSwipeOffset, normalizedStartingPointX, normalizedStartingPointY);
-    return await new ActionInteraction(this._invocationManager, this, action).execute();
+    const traceDescription = actionDescription.swipe(direction, speed, normalizedSwipeOffset, normalizedStartingPointX, normalizedStartingPointY);
+    return await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
   }
 
   async takeScreenshot(screenshotName) {
     // TODO this should be moved to a lower-layer handler of this use-case
-    const resultBase64 = await new ActionInteraction(this._invocationManager, this, new actions.TakeElementScreenshot()).execute();
+    const action = new actions.TakeElementScreenshot();
+    const traceDescription = actionDescription.takeScreenshot(screenshotName);
+    const resultBase64 = await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
     const filePath = tempfile('detox.element-screenshot.png');
     await fs.writeFile(filePath, resultBase64, 'base64');
 
@@ -115,12 +147,16 @@ class NativeElement {
   }
 
   async getAttributes() {
-    const result = await new ActionInteraction(this._invocationManager, this, new actions.GetAttributes()).execute();
+    const action = new actions.GetAttributes();
+    const traceDescription = actionDescription.getAttributes();
+    const result = await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
     return JSON.parse(result);
   }
 
   async adjustSliderToPosition(newPosition) {
-    return await new ActionInteraction(this._invocationManager, this, new actions.AdjustSliderToPosition(newPosition)).execute();
+    const action = new actions.AdjustSliderToPosition(newPosition);
+    const traceDescription = actionDescription.adjustSliderToPosition(newPosition);
+    return await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
   }
 }
 

package/src/android/core/NativeExpect.js

@@ -1,3 +1,4 @@
+const { expectDescription } = require('../../utils/invocationTraceDescriptions');
 const { MatcherAssertionInteraction } = require('../interactions/native');
 const matchers = require('../matchers/native');
 
@@ -19,7 +20,9 @@ class NativeExpectElement extends NativeExpect {
   }
 
   async toBeVisible(pct) {
-    return await new MatcherAssertionInteraction(this._invocationManager, this._element, this._notCondition ? new matchers.VisibleMatcher(pct).not : new matchers.VisibleMatcher(pct)).execute();
+    const matcher = new matchers.VisibleMatcher(pct);
+    const traceDescription = expectDescription.toBeVisible(pct);
+    return await new MatcherAssertionInteraction(this._invocationManager, this._element, matcher, this._notCondition, traceDescription).execute();
   }
 
   async toBeNotVisible() {
@@ -27,7 +30,9 @@ class NativeExpectElement extends NativeExpect {
   }
 
   async toExist() {
-    return await new MatcherAssertionInteraction(this._invocationManager, this._element, this._notCondition ? new matchers.ExistsMatcher().not : new matchers.ExistsMatcher()).execute();
+    const matcher = new matchers.ExistsMatcher();
+    const traceDescription = expectDescription.toExist();
+    return await new MatcherAssertionInteraction(this._invocationManager, this._element, matcher, this._notCondition, traceDescription).execute();
   }
 
   async toNotExist() {
@@ -35,7 +40,9 @@ class NativeExpectElement extends NativeExpect {
   }
 
   async toHaveText(text) {
-    return await new MatcherAssertionInteraction(this._invocationManager, this._element, this._notCondition ? new matchers.TextMatcher(text).not : new matchers.TextMatcher(text)).execute();
+    const matcher = new matchers.TextMatcher(text);
+    const traceDescription = expectDescription.toHaveText(text);
+    return await new MatcherAssertionInteraction(this._invocationManager, this._element, matcher, this._notCondition, traceDescription).execute();
   }
 
   async toNotHaveText(text) {
@@ -43,7 +50,9 @@ class NativeExpectElement extends NativeExpect {
   }
 
   async toHaveLabel(value) {
-    return await new MatcherAssertionInteraction(this._invocationManager, this._element, this._notCondition ? new matchers.LabelMatcher(value).not : new matchers.LabelMatcher(value)).execute();
+    const matcher = new matchers.LabelMatcher(value);
+    const traceDescription = expectDescription.toHaveLabel(value);
+    return await new MatcherAssertionInteraction(this._invocationManager, this._element, matcher, this._notCondition, traceDescription).execute();
   }
 
   async toNotHaveLabel(value) {
@@ -51,7 +60,9 @@ class NativeExpectElement extends NativeExpect {
   }
 
   async toHaveId(value) {
-    return await new MatcherAssertionInteraction(this._invocationManager, this._element, this._notCondition ? new matchers.IdMatcher(value).not : new matchers.IdMatcher(value)).execute();
+    const matcher = new matchers.IdMatcher(value);
+    const traceDescription = expectDescription.toHaveId(value);
+    return await new MatcherAssertionInteraction(this._invocationManager, this._element, matcher, this._notCondition, traceDescription).execute();
   }
 
   async toNotHaveId(value) {
@@ -59,7 +70,9 @@ class NativeExpectElement extends NativeExpect {
   }
 
   async toHaveValue(value) {
-    return await new MatcherAssertionInteraction(this._invocationManager, this._element, this._notCondition ? new matchers.ValueMatcher(value).not : new matchers.ValueMatcher(value)).execute();
+    const matcher = new matchers.ValueMatcher(value);
+    const traceDescription = expectDescription.toHaveValue(value);
+    return await new MatcherAssertionInteraction(this._invocationManager, this._element, matcher, this._notCondition, traceDescription).execute();
   }
 
   async toNotHaveValue(value) {
@@ -67,15 +80,21 @@ class NativeExpectElement extends NativeExpect {
   }
 
   async toHaveToggleValue(value) {
-    return await new MatcherAssertionInteraction(this._invocationManager, this._element, this._notCondition ? new matchers.ToggleMatcher(value).not : new matchers.ToggleMatcher(value)).execute();
+    const matcher = new matchers.ToggleMatcher(value);
+    const traceDescription = expectDescription.toHaveToggleValue(value);
+    return await new MatcherAssertionInteraction(this._invocationManager, this._element, matcher, this._notCondition, traceDescription).execute();
   }
 
   async toHaveSliderPosition(value, tolerance = 0) {
-    return await new MatcherAssertionInteraction(this._invocationManager, this._element, this._notCondition ? new matchers.SliderPositionMatcher(value, tolerance).not : new matchers.SliderPositionMatcher(value, tolerance)).execute();
+    const matcher = new matchers.SliderPositionMatcher(value, tolerance);
+    const traceDescription = expectDescription.toHaveSliderPosition(value, tolerance);
+    return await new MatcherAssertionInteraction(this._invocationManager, this._element, matcher, this._notCondition, traceDescription).execute();
   }
 
   async toBeFocused() {
-    return await new MatcherAssertionInteraction(this._invocationManager, this._element, this._notCondition ? new matchers.FocusMatcher().not : new matchers.FocusMatcher()).execute();
+    const matcher = new matchers.FocusMatcher();
+    const traceDescription = expectDescription.toBeFocused();
+    return await new MatcherAssertionInteraction(this._invocationManager, this._element, matcher, this._notCondition, traceDescription).execute();
   }
 
   async toBeNotFocused() {

package/src/android/interactions/native.js

@@ -1,4 +1,6 @@
 const DetoxRuntimeError = require('../../errors/DetoxRuntimeError');
+const { expectDescription, actionDescription } = require('../../utils/invocationTraceDescriptions');
+const { trace } = require('../../utils/trace');
 const { ScrollAmountStopAtEdgeAction } = require('../actions/native');
 const { NativeMatcher } = require('../core/NativeMatcher');
 const DetoxAssertionApi = require('../espressoapi/DetoxAssertion');
@@ -9,45 +11,50 @@ function call(maybeAFunction) {
 }
 
 class Interaction {
-  constructor(invocationManager) {
+  constructor(invocationManager, traceDescription) {
     this._call = undefined;
+    this._traceDescription = traceDescription;
     this._invocationManager = invocationManager;
   }
 
   async execute() {
-    const resultObj = await this._invocationManager.execute(this._call);
-    return resultObj ? resultObj.result : undefined;
+    return trace.invocationCall(this._traceDescription, this._call,
+      this._invocationManager.execute(this._call).then((resultObj) => resultObj ? resultObj.result : undefined));
   }
 }
 
 class ActionInteraction extends Interaction {
-  constructor(invocationManager, element, action) {
-    super(invocationManager);
+  constructor(invocationManager, element, action, traceDescription) {
+    super(invocationManager, traceDescription);
     this._call = EspressoDetoxApi.perform(call(element._call), action._call);
     // TODO: move this.execute() here from the caller
   }
 }
 
 class MatcherAssertionInteraction extends Interaction {
-  constructor(invocationManager, element, matcher) {
-    super(invocationManager);
+  constructor(invocationManager, element, matcher, notCondition, traceDescription) {
+    traceDescription = expectDescription.full(traceDescription, notCondition);
+    super(invocationManager, traceDescription);
+
+    matcher = notCondition ? matcher.not : matcher;
     this._call = DetoxAssertionApi.assertMatcher(call(element._call), matcher._call.value);
     // TODO: move this.execute() here from the caller
   }
 }
 
 class WaitForInteraction extends Interaction {
-  constructor(invocationManager, element, assertionMatcher) {
-    super(invocationManager);
+  constructor(invocationManager, element, assertionMatcher, expectTraceDescription) {
+    super(invocationManager, expectTraceDescription);
     this._element = element;
     this._assertionMatcher = assertionMatcher;
     this._element._selectElementWithMatcher(this._element._originalMatcher);
   }
 
   async withTimeout(timeout) {
-    if (typeof timeout !== 'number') throw new DetoxRuntimeError(`WaitForInteraction withTimeout argument must be a number, got ${typeof timeout}`);
-    if (timeout < 0) throw new DetoxRuntimeError('timeout must be larger than 0');
+    if (typeof timeout !== 'number') throw new DetoxRuntimeError({ message: `WaitForInteraction withTimeout argument must be a number, got ${typeof timeout}` });
+    if (timeout < 0) throw new DetoxRuntimeError({ message: 'timeout must be larger than 0' });
 
+    this._traceDescription = expectDescription.waitForWithTimeout(this._traceDescription, timeout);
     this._call = DetoxAssertionApi.waitForAssertMatcher(call(this._element._call), this._assertionMatcher._call.value, timeout / 1000);
     await this.execute();
   }
@@ -58,20 +65,18 @@ class WaitForInteraction extends Interaction {
 }
 
 class WaitForActionInteractionBase extends Interaction {
-  constructor(invocationManager, element, matcher, searchMatcher) {
-    super(invocationManager);
-    //if (!(element instanceof NativeElement)) throw new DetoxRuntimeError(`WaitForActionInteraction ctor 1st argument must be a valid NativeElement, got ${typeof element}`);
-    //if (!(matcher instanceof NativeMatcher)) throw new DetoxRuntimeError(`WaitForActionInteraction ctor 2nd argument must be a valid NativeMatcher, got ${typeof matcher}`);
+  constructor(invocationManager, element, matcher, searchMatcher, traceDescription) {
+    super(invocationManager, traceDescription);
+
     if (!(searchMatcher instanceof NativeMatcher))
-      throw new DetoxRuntimeError(`WaitForActionInteraction ctor 3rd argument must be a valid NativeMatcher, got ${typeof searchMatcher}`);
+      throw new DetoxRuntimeError({ message: `WaitForActionInteraction ctor 3rd argument must be a valid NativeMatcher, got ${typeof searchMatcher}` });
+
     this._element = element;
     this._originalMatcher = matcher;
     this._searchMatcher = searchMatcher;
   }
 
   _prepare(searchAction) {
-    //if (!searchAction instanceof Action) throw new DetoxRuntimeError(`WaitForActionInteraction _execute argument must be a valid Action, got ${typeof searchAction}`);
-
     this._call = DetoxAssertionApi.waitForAssertMatcherWithSearchAction(
       call(this._element._call),
       call(this._originalMatcher._call).value,
@@ -83,6 +88,7 @@ class WaitForActionInteractionBase extends Interaction {
 
 class WaitForActionInteraction extends WaitForActionInteractionBase {
   async scroll(amount, direction = 'down', scrollPositionX, scrollPositionY) {
+    this._traceDescription = expectDescription.waitFor(actionDescription.scroll(amount, direction, scrollPositionX, scrollPositionY));
     this._prepare(new ScrollAmountStopAtEdgeAction(direction, amount, scrollPositionX, scrollPositionY));
     await this.execute();
   }

package/src/artifacts/timeline/TimelineContextTypes.js

@@ -0,0 +1,7 @@
+const TIMELINE_CONTEXT_TYPES = {
+  TEST: 'test',
+  DESCRIBE: 'describe',
+  INVOCATION: 'invocation'
+};
+
+module.exports = TIMELINE_CONTEXT_TYPES;