detox 19.9.3 → 19.12.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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "detox",
   "description": "E2E tests and automation for mobile",
-  "version": "19.9.3",
+  "version": "19.12.0",
   "bin": {
     "detox": "local-cli/cli.js"
   },
@@ -47,7 +47,7 @@
     "mocha": ">=6.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"
@@ -177,5 +177,5 @@
       }
     }
   },
-  "gitHead": "430c72e278639ff07c1b3f4a491baafa5b72acb1"
+  "gitHead": "c283efc9a8db72304b73ca054ccaa8acb6b3284c"
 }

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

@@ -22,16 +22,6 @@ class DetoxCoreListener {
     this.detox = detox;
   }
 
-  _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 run_describe_start({ describeBlock: { name, children } }) {
     if (children.length) {
       await this.detox[onRunDescribeStart]({ name });
@@ -80,20 +70,39 @@ class DetoxCoreListener {
     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),
       status: 'running',
+      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]({
-        title: test.name,
-        fullName: getFullTestName(test),
-        status: test.errors.length ? 'failed' : 'passed',
-        invocations: this._getTestInvocations(test),
+        ...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)
       });
 

package/src/DetoxExportWrapper.js

@@ -66,7 +66,7 @@ class DetoxExportWrapper {
       }
 
       this[_detox] = new Detox(resolvedConfig);
-      await traceCall('detoxInit', () => this[_detox].init());
+      await traceCall('detoxInit', this[_detox].init());
       Detox.none.setError(null);
 
       return this[_detox];

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 { traceInvocationCall } = 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 traceInvocationCall(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/TimelineArtifactPlugin.js

@@ -7,16 +7,13 @@ const { trace } = require('../../utils/trace');
 const FileArtifact = require('../templates/artifact/FileArtifact');
 const ArtifactPlugin = require('../templates/plugin/ArtifactPlugin');
 
+const TIMELINE_CONTEXT_TYPES = require('./TimelineContextTypes');
+
 const traceNoop = {
   startSection: _noop,
   endSection: _noop,
 };
 
-const CONTEXT_TYPES = {
-  TEST: 'test',
-  DESCRIBE: 'describe'
-};
-
 class TimelineArtifactPlugin extends ArtifactPlugin {
   constructor(config) {
     super(config);
@@ -37,23 +34,23 @@ class TimelineArtifactPlugin extends ArtifactPlugin {
 
   async onRunDescribeStart(suite) {
     const sectionName = (suite.name === 'ROOT_DESCRIBE_BLOCK' ? this._deviceName : suite.name);
-    this._trace.startSection(sectionName, { context: CONTEXT_TYPES.DESCRIBE });
+    this._trace.startSection(sectionName, { context: TIMELINE_CONTEXT_TYPES.DESCRIBE });
     await super.onRunDescribeStart(suite);
   }
 
   async onRunDescribeFinish(suite) {
     const sectionName = (suite.name === 'ROOT_DESCRIBE_BLOCK' ? this._deviceName : suite.name);
-    this._trace.endSection(sectionName, { context: CONTEXT_TYPES.DESCRIBE });
+    this._trace.endSection(sectionName, { context: TIMELINE_CONTEXT_TYPES.DESCRIBE });
     await super.onRunDescribeFinish(suite);
   }
 
   async onTestStart(testSummary) {
-    this._trace.startSection(testSummary.title, { context: CONTEXT_TYPES.TEST });
+    this._trace.startSection(testSummary.title, { context: TIMELINE_CONTEXT_TYPES.TEST, ...testSummary });
     await super.onTestStart(testSummary);
   }
 
   async onTestDone(testSummary) {
-    this._trace.endSection(testSummary.title, { status: testSummary.status, context: CONTEXT_TYPES.TEST });
+    this._trace.endSection(testSummary.title, { context: TIMELINE_CONTEXT_TYPES.TEST, ...testSummary });
     await super.onTestDone(testSummary);
   }
 

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;

package/src/client/Client.js

@@ -34,6 +34,7 @@ class Client {
     this._slowInvocationStatusHandle = null;
     this._whenAppIsConnected = this._invalidState('before connecting to the app');
     this._whenAppIsReady = this._whenAppIsConnected;
+    this._whenAppDisconnected = Deferred.resolved();
     this._isCleaningUp = false;
     this._pendingAppCrash = null;
     this._appTerminationHandle = null;
@@ -201,6 +202,11 @@ class Client {
     }
   }
 
+  /** @async */
+  waitUntilDisconnected() {
+    return this._whenAppDisconnected.promise;
+  }
+
   async waitForBackground() {
     await this.sendAction(new actions.WaitForBackground());
   }
@@ -301,6 +307,8 @@ class Client {
     } else {
       this._whenAppIsConnected = Deferred.resolved();
     }
+
+    this._whenAppDisconnected = new Deferred();
   }
 
   _onAppReady() {
@@ -320,6 +328,10 @@ class Client {
   }
 
   _onBeforeAppCrash({ params }) {
+    if (this._pendingAppCrash) {
+      return;
+    }
+
     this._pendingAppCrash = new DetoxRuntimeError({
       message: 'The app has crashed, see the details below:',
       debugInfo: params.errorDetails,
@@ -338,10 +350,15 @@ class Client {
     this._whenAppIsReady = this._whenAppIsConnected;
 
     if (this._pendingAppCrash) {
+      this._whenAppDisconnected.reject(this._pendingAppCrash);
       this._asyncWebSocket.rejectAll(this._pendingAppCrash);
       this._pendingAppCrash = null;
     } else if (this._asyncWebSocket.hasPendingActions()) {
-      this._asyncWebSocket.rejectAll(new DetoxRuntimeError('The app has unexpectedly disconnected from Detox server.'));
+      const error = new DetoxRuntimeError('The app has unexpectedly disconnected from Detox server.');
+      this._asyncWebSocket.rejectAll(error);
+      this._whenAppDisconnected.resolve();
+    } else {
+      this._whenAppDisconnected.resolve();
     }
   }
 

package/src/devices/allocation/DeviceAllocator.js

@@ -14,8 +14,7 @@ class DeviceAllocator {
    * @return {Promise<DeviceCookie>}
    */
   allocate(deviceConfig) {
-    return traceCall('allocateDevice', () =>
-      this._driver.allocate(deviceConfig));
+    return traceCall('allocateDevice', this._driver.allocate(deviceConfig));
   }
 
   /**